@abraca/cli 1.5.0

package/src/commands/meta.ts

@@ -0,0 +1,149 @@
+/**
+ * Metadata commands: meta, tags.
+ */
+import * as Y from 'yjs'
+import { registerCommand } from '../command.ts'
+import type { CLIConnection } from '../connection.ts'
+import type { ParsedArgs } from '../parser.ts'
+import { readEntries, resolveDocument } from '../resolve.ts'
+import { printJson, printTable, getFormat } from '../output.ts'
+
+/** Safely read a tree map value. */
+function toPlain(val: any): any {
+  return val instanceof Y.Map ? val.toJSON() : val
+}
+
+registerCommand({
+  name: 'meta',
+  aliases: ['metadata'],
+  description: 'Get or set document metadata.',
+  usage: 'meta id=<docId> | name=<label> [key=value ...] [--format=json]',
+  async run(conn: CLIConnection | null, args: ParsedArgs): Promise<string> {
+    if (!conn) return 'Not connected'
+
+    const docId = resolveDocument(conn, args.params, args.positional)
+    if (!docId) return 'Document not found.'
+
+    const treeMap = conn.getTreeMap()
+    if (!treeMap) return 'Not connected'
+
+    const raw = treeMap.get(docId)
+    if (!raw) return `Document ${docId} not found.`
+
+    const entry = toPlain(raw)
+
+    // Collect meta updates from remaining params
+    const metaKeys = new Set(['icon', 'color', 'priority', 'status', 'checked', 'rating',
+      'tags', 'dateStart', 'dateEnd', 'datetimeStart', 'datetimeEnd', 'allDay',
+      'url', 'email', 'phone', 'number', 'unit', 'subtitle', 'note',
+      'taskProgress', 'coverUploadId', 'geoType', 'geoLat', 'geoLng',
+      'deskX', 'deskY', 'deskMode', 'spShape', 'spColor', 'chartType',
+      'kanbanColumnWidth', 'galleryColumns', 'calendarView', 'tableMode',
+    ])
+
+    const updates: Record<string, unknown> = {}
+    let hasUpdates = false
+
+    for (const [key, value] of Object.entries(args.params)) {
+      if (metaKeys.has(key)) {
+        // Parse special types
+        if (value === 'null') {
+          updates[key] = null
+        } else if (value === 'true') {
+          updates[key] = true
+        } else if (value === 'false') {
+          updates[key] = false
+        } else if (['priority', 'rating', 'number', 'taskProgress', 'geoLat', 'geoLng',
+                     'deskX', 'deskY', 'galleryColumns'].includes(key)) {
+          updates[key] = parseFloat(value)
+        } else if (key === 'tags') {
+          updates[key] = value.split(',').map(s => s.trim())
+        } else {
+          updates[key] = value
+        }
+        hasUpdates = true
+      }
+    }
+
+    if (hasUpdates) {
+      // Write mode: merge updates into existing meta
+      treeMap.set(docId, {
+        ...entry,
+        meta: { ...(entry.meta ?? {}), ...updates },
+        updatedAt: Date.now(),
+      })
+      return `Metadata updated for ${docId.slice(0, 8)}…`
+    }
+
+    // Read mode: display current metadata
+    const meta = entry.meta ?? {}
+    if (args.params['format'] === 'json') {
+      return printJson({ id: docId, label: entry.label, type: entry.type, meta })
+    }
+
+    if (Object.keys(meta).length === 0) {
+      return `Document "${entry.label}" has no metadata.`
+    }
+
+    const lines = Object.entries(meta).map(([k, v]) =>
+      `${k}: ${typeof v === 'object' ? JSON.stringify(v) : v}`
+    )
+    return lines.join('\n')
+  },
+})
+
+registerCommand({
+  name: 'tags',
+  description: 'List tags aggregated from document metadata.',
+  usage: 'tags [id=<docId>] [--counts] [--total] [--format=json|tsv]',
+  async run(conn: CLIConnection | null, args: ParsedArgs): Promise<string> {
+    if (!conn) return 'Not connected'
+    const treeMap = conn.getTreeMap()
+    if (!treeMap) return 'Not connected'
+
+    // If a document is specified, show its tags
+    const docId = resolveDocument(conn, args.params, args.positional)
+    if (docId) {
+      const raw = treeMap.get(docId)
+      if (!raw) return `Document ${docId} not found.`
+      const entry = toPlain(raw)
+      const tags: string[] = entry.meta?.tags ?? []
+      if (tags.length === 0) return 'No tags.'
+      return tags.join('\n')
+    }
+
+    // Aggregate tags from all documents
+    const entries = readEntries(treeMap)
+    const tagCounts = new Map<string, number>()
+
+    for (const entry of entries) {
+      const tags: string[] = (entry.meta as any)?.tags ?? []
+      for (const tag of tags) {
+        tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1)
+      }
+    }
+
+    if (tagCounts.size === 0) return 'No tags found.'
+
+    if (args.flags.has('total')) {
+      return String(tagCounts.size)
+    }
+
+    const sorted = [...tagCounts.entries()].sort((a, b) => {
+      if (args.params['sort'] === 'count') return b[1] - a[1]
+      return a[0].localeCompare(b[0])
+    })
+
+    const format = getFormat(args, 'text')
+
+    if (format === 'json') {
+      return printJson(sorted.map(([tag, count]) => ({ tag, count })))
+    }
+
+    if (args.flags.has('counts')) {
+      return sorted.map(([tag, count]) => `${tag}\t${count}`).join('\n')
+    }
+
+    return sorted.map(([tag]) => tag).join('\n')
+  },
+})

package/src/commands/permissions.ts

@@ -0,0 +1,94 @@
+/**
+ * Permission commands: permissions.
+ */
+import { registerCommand } from '../command.ts'
+import type { CLIConnection } from '../connection.ts'
+import type { ParsedArgs } from '../parser.ts'
+import { resolveDocument } from '../resolve.ts'
+import { printJson, printTable, getFormat } from '../output.ts'
+
+registerCommand({
+  name: 'permissions',
+  aliases: ['perms'],
+  description: 'List or set document permissions.',
+  usage: 'permissions id=<docId> [user=<userId> role=<role>] [--effective] [--format=json|tsv]',
+  async run(conn: CLIConnection | null, args: ParsedArgs): Promise<string> {
+    if (!conn) return 'Not connected'
+
+    const docId = resolveDocument(conn, args.params, args.positional)
+    if (!docId) return 'Document not found.'
+
+    // Set permission mode
+    const targetUser = args.params['user'] || args.params['user_id']
+    const targetRole = args.params['role']
+
+    if (targetUser && targetRole) {
+      try {
+        await conn.client.setPermission(docId, {
+          user_id: targetUser,
+          role: targetRole as 'owner' | 'editor' | 'viewer' | 'observer',
+        })
+        return `Set ${targetUser.slice(0, 12)}… → ${targetRole} on ${docId.slice(0, 8)}…`
+      } catch (error: any) {
+        return `Error: ${error.message}`
+      }
+    }
+
+    // Remove permission mode
+    if (targetUser && args.flags.has('remove')) {
+      try {
+        await conn.client.removePermission(docId, { user_id: targetUser })
+        return `Removed permissions for ${targetUser.slice(0, 12)}… on ${docId.slice(0, 8)}…`
+      } catch (error: any) {
+        return `Error: ${error.message}`
+      }
+    }
+
+    // List permissions mode
+    try {
+      const format = getFormat(args, 'text')
+
+      if (args.flags.has('effective')) {
+        const result = await conn.client.listEffectivePermissions(docId)
+
+        if (format === 'json') {
+          return printJson(result)
+        }
+
+        if (result.permissions.length === 0) {
+          return `Default role: ${result.default_role}\nNo explicit permissions.`
+        }
+
+        const rows = result.permissions.map(p => [
+          p.display_name || p.username,
+          p.role,
+          p.source,
+          p.inherited_from_doc_id ? p.inherited_from_doc_id.slice(0, 8) + '…' : '—',
+        ])
+
+        return `Default role: ${result.default_role}\n\n` +
+          printTable(rows, ['USER', 'ROLE', 'SOURCE', 'INHERITED FROM'])
+      }
+
+      const perms = await conn.client.listPermissions(docId)
+
+      if (format === 'json') {
+        return printJson(perms)
+      }
+
+      if (perms.length === 0) {
+        return 'No explicit permissions set.'
+      }
+
+      const rows = perms.map(p => [
+        p.display_name || p.username,
+        p.role,
+        p.user_id.slice(0, 12) + '…',
+      ])
+
+      return printTable(rows, ['USER', 'ROLE', 'USER ID'])
+    } catch (error: any) {
+      return `Error: ${error.message}`
+    }
+  },
+})

package/src/commands/spaces.ts

@@ -0,0 +1,100 @@
+/**
+ * spaces, spaces:switch, info commands.
+ */
+import { registerCommand } from '../command.ts'
+import type { CLIConnection } from '../connection.ts'
+import type { ParsedArgs } from '../parser.ts'
+import { printJson, printTable, getFormat, pad } from '../output.ts'
+import { readEntries, childrenOf } from '../resolve.ts'
+
+registerCommand({
+  name: 'info',
+  description: 'Show server and space info.',
+  async run(conn: CLIConnection | null): Promise<string> {
+    if (!conn) return 'Not connected'
+    const si = conn.serverInfo
+    if (!si) return 'No server info available'
+
+    const treeMap = conn.getTreeMap()
+    const docCount = treeMap ? readEntries(treeMap).length : 0
+
+    const rootProvider = conn.rootProvider
+    const onlineUsers = rootProvider
+      ? Array.from(rootProvider.awareness.getStates().values()).filter((s: any) => s.user).length
+      : 0
+
+    const lines = [
+      `Server:      ${si.name ?? '—'}`,
+      `URL:         ${conn.config.url}`,
+      `Version:     ${si.version ?? '—'}`,
+      `Protocol:    ${si.protocol_version ?? '—'}`,
+      `Hub Doc:     ${conn.rootDocId ?? '—'}`,
+      `Auth:        ${si.auth_methods?.join(', ') ?? '—'}`,
+      `Registration:${si.registration_allowed ? ' open' : ' closed'}${si.invite_only ? ' (invite only)' : ''}`,
+      `Documents:   ${docCount}`,
+      `Users:       ${onlineUsers} online`,
+    ]
+    return lines.join('\n')
+  },
+})
+
+registerCommand({
+  name: 'spaces',
+  description: 'List available spaces/root documents.',
+  usage: 'spaces [--format=json|tsv]',
+  async run(conn: CLIConnection | null, args: ParsedArgs): Promise<string> {
+    if (!conn) return 'Not connected'
+    const spaces = conn.spaces
+    if (!spaces.length) return 'No spaces available.'
+
+    const format = getFormat(args, 'text')
+    const active = conn.rootDocId
+
+    if (format === 'json') {
+      return printJson(spaces.map(s => ({ ...s, active: s.doc_id === active })))
+    }
+
+    const rows = spaces.map(s => [
+      s.doc_id === active ? '▸' : ' ',
+      s.doc_id.slice(0, 8) + '…',
+      s.name,
+      s.is_hub ? 'hub' : '',
+      s.visibility,
+    ])
+
+    return printTable(rows, ['', 'ID', 'NAME', 'HUB', 'VISIBILITY'])
+  },
+})
+
+registerCommand({
+  name: 'spaces:switch',
+  aliases: ['switch'],
+  description: 'Switch the active space.',
+  usage: 'spaces:switch name=<name> | id=<docId>',
+  async run(conn: CLIConnection | null, args: ParsedArgs): Promise<string> {
+    if (!conn) return 'Not connected'
+
+    const targetName = args.params['name'] || args.positional[0]
+    const targetId = args.params['id']
+
+    let docId: string | null = null
+
+    if (targetId) {
+      docId = targetId
+    } else if (targetName) {
+      const lower = targetName.toLowerCase()
+      const space = conn.spaces.find(s =>
+        s.name.toLowerCase() === lower || s.doc_id === targetName
+      )
+      if (space) docId = space.doc_id
+    }
+
+    if (!docId) {
+      return 'Space not found. Use "abracadabra spaces" to list available spaces.'
+    }
+
+    await conn.switchSpace(docId)
+    const space = conn.spaces.find(s => s.doc_id === docId)
+    return `Switched to space "${space?.name ?? docId}"`
+  },
+})

package/src/commands/tree.ts

@@ -0,0 +1,158 @@
+/**
+ * tree, ls, search commands — navigate and explore the document tree.
+ */
+import { registerCommand } from '../command.ts'
+import type { CLIConnection } from '../connection.ts'
+import type { ParsedArgs } from '../parser.ts'
+import {
+  readEntries,
+  childrenOf,
+  buildTree,
+  normalizeRootId,
+  resolveDocument,
+  getAncestorPath,
+  type TreeDisplayNode,
+} from '../resolve.ts'
+import { printJson, printTable, printTree, getFormat, relativeTime, type TreeNode } from '../output.ts'
+
+function toTreeNodes(nodes: TreeDisplayNode[]): TreeNode[] {
+  return nodes.map(n => ({
+    label: n.label,
+    type: n.type,
+    children: n.children.length > 0 ? toTreeNodes(n.children) : undefined,
+  }))
+}
+
+registerCommand({
+  name: 'tree',
+  aliases: ['t'],
+  description: 'Show the full document tree hierarchy.',
+  usage: 'tree [id=<docId>] [depth=<n>] [--format=json|tree]',
+  async run(conn: CLIConnection | null, args: ParsedArgs): Promise<string> {
+    if (!conn) return 'Not connected'
+    const treeMap = conn.getTreeMap()
+    if (!treeMap) return 'Not connected'
+
+    const rootId = normalizeRootId(
+      args.params['id'] || args.positional[0] || conn.rootDocId,
+      conn
+    )
+    const maxDepth = args.params['depth'] ? parseInt(args.params['depth'], 10) : -1
+    const format = getFormat(args, 'tree')
+
+    const entries = readEntries(treeMap)
+    const tree = buildTree(entries, rootId, maxDepth)
+
+    if (format === 'json') {
+      return printJson(tree)
+    }
+
+    if (tree.length === 0) {
+      return '(empty tree)'
+    }
+
+    // Find root label for header
+    const hubSpace = conn.spaces.find(s => s.doc_id === conn.rootDocId)
+    const rootLabel = hubSpace?.name ?? conn.rootDocId ?? 'Workspace'
+
+    return rootLabel + '\n' + printTree(toTreeNodes(tree))
+  },
+})
+
+registerCommand({
+  name: 'ls',
+  aliases: ['list', 'l'],
+  description: 'List direct children of a document (defaults to root).',
+  usage: 'ls [id=<parentId>] [name=<parentName>] [--format=json|tsv] [--total]',
+  async run(conn: CLIConnection | null, args: ParsedArgs): Promise<string> {
+    if (!conn) return 'Not connected'
+    const treeMap = conn.getTreeMap()
+    if (!treeMap) return 'Not connected'
+
+    let parentId: string | null = null
+    if (args.params['id'] || args.params['name'] || args.params['path'] || args.positional[0]) {
+      parentId = resolveDocument(conn, args.params, args.positional)
+      if (!parentId && (args.params['id'] || args.params['name'] || args.params['path'])) {
+        return 'Document not found.'
+      }
+    }
+
+    const targetId = normalizeRootId(parentId || conn.rootDocId, conn)
+    const entries = readEntries(treeMap)
+    const children = childrenOf(entries, targetId)
+
+    if (args.flags.has('total')) {
+      return String(children.length)
+    }
+
+    const format = getFormat(args, 'text')
+
+    if (format === 'json') {
+      return printJson(children)
+    }
+
+    if (children.length === 0) {
+      return '(no children)'
+    }
+
+    const rows = children.map(c => [
+      c.id.slice(0, 8) + '…',
+      c.label,
+      c.type ?? '—',
+      relativeTime(c.updatedAt),
+    ])
+
+    return printTable(rows, ['ID', 'LABEL', 'TYPE', 'UPDATED'])
+  },
+})
+
+registerCommand({
+  name: 'search',
+  aliases: ['find', 's'],
+  description: 'Search documents by label across the tree.',
+  usage: 'search query=<text> [id=<rootId>] [--format=json|tsv] [--total]',
+  async run(conn: CLIConnection | null, args: ParsedArgs): Promise<string> {
+    if (!conn) return 'Not connected'
+    const treeMap = conn.getTreeMap()
+    if (!treeMap) return 'Not connected'
+
+    const query = args.params['query'] || args.positional[0]
+    if (!query) return 'Missing required parameter: query=<text>'
+
+    const entries = readEntries(treeMap)
+    const lowerQuery = query.toLowerCase()
+
+    const matches = entries.filter(e =>
+      e.label.toLowerCase().includes(lowerQuery)
+    )
+
+    if (args.flags.has('total')) {
+      return String(matches.length)
+    }
+
+    const format = getFormat(args, 'text')
+
+    if (matches.length === 0) {
+      return `No documents found matching "${query}".`
+    }
+
+    const results = matches.map(entry => ({
+      id: entry.id,
+      label: entry.label,
+      type: entry.type,
+      path: getAncestorPath(entries, entry.id),
+    }))
+
+    if (format === 'json') {
+      return printJson(results)
+    }
+
+    const rows = results.map(r => [
+      r.path.length > 0 ? r.path.join(' / ') + ' / ' + r.label : r.label,
+      r.label,
+      r.type ?? '—',
+    ])
+
+    return printTable(rows, ['PATH', 'LABEL', 'TYPE'])
+  },
+})