@upgraide/ui-notes-cli 0.1.1 → 0.1.3

package/formatters/ai-context.ts

@@ -0,0 +1,236 @@
+import type { ResolvedNote, FileMatch } from '../resolvers/file-resolver.js';
+
+interface Note {
+  id: string;
+  type: string;
+  body: string;
+  url: string;
+  component: string | null;
+  selector: string | null;
+  tag: string | null;
+  text_content: string | null;
+  created_at: string;
+}
+
+interface FormatOptions {
+  format: 'markdown' | 'xml' | 'json';
+  componentFilter?: string;
+  projectName: string;
+  resolvedNotes?: Map<string, ResolvedNote>;
+}
+
+export function formatNotesForAI(notes: Note[], opts: FormatOptions): string {
+  // Filter by component if specified
+  let filtered = notes;
+  if (opts.componentFilter) {
+    filtered = notes.filter(n =>
+      n.component?.toLowerCase().includes(opts.componentFilter!.toLowerCase())
+    );
+  }
+
+  // Group by component
+  const grouped = new Map<string, Note[]>();
+  for (const note of filtered) {
+    const key = note.component || '_unresolved';
+    if (!grouped.has(key)) grouped.set(key, []);
+    grouped.get(key)!.push(note);
+  }
+
+  const date = new Date().toISOString().split('T')[0];
+
+  if (opts.format === 'xml') {
+    return formatAsXML(grouped, filtered.length, opts.projectName, date, opts.resolvedNotes);
+  }
+  if (opts.format === 'json') {
+    return formatAsJSON(grouped, filtered.length, opts.projectName, date, opts.resolvedNotes);
+  }
+  return formatAsMarkdown(grouped, filtered.length, opts.projectName, date, opts.resolvedNotes);
+}
+
+function formatFileMatch(file: FileMatch): string {
+  const loc = file.lineNumber ? `${file.filePath}:${file.lineNumber}` : file.filePath;
+  return `\`${loc}\` (${file.confidence} confidence, matched on ${file.matchedOn})`;
+}
+
+function formatAsMarkdown(
+  grouped: Map<string, Note[]>,
+  total: number,
+  projectName: string,
+  date: string,
+  resolvedNotes?: Map<string, ResolvedNote>,
+): string {
+  const lines: string[] = [];
+
+  lines.push(`# UI Notes: ${projectName}`);
+
+  if (total === 0) {
+    lines.push('> No open notes.');
+    return lines.join('\n') + '\n';
+  }
+
+  const resolveInfo = resolvedNotes ? ' | File resolution: enabled' : '';
+  lines.push(`> ${total} open note${total === 1 ? '' : 's'} as of ${date}${resolveInfo}`);
+  lines.push('');
+
+  for (const [component, notes] of grouped) {
+    if (component === '_unresolved') {
+      lines.push(`## _Unresolved (${notes.length} note${notes.length === 1 ? '' : 's'})`);
+    } else {
+      lines.push(`## Component: ${component} (${notes.length} note${notes.length === 1 ? '' : 's'})`);
+    }
+    lines.push('');
+
+    for (const note of notes) {
+      const typeLabel = (note.type || 'note').toUpperCase();
+      const firstLine = note.body?.split('\n')[0] || '(no body)';
+      lines.push(`### [${typeLabel}] ${firstLine}`);
+
+      // File resolution output
+      if (resolvedNotes) {
+        const resolved = resolvedNotes.get(note.id);
+        if (resolved && resolved.files.length > 0) {
+          for (const file of resolved.files) {
+            lines.push(`- **File**: ${formatFileMatch(file)}`);
+          }
+        } else {
+          lines.push(`- **File**: _(no match found)_`);
+        }
+      }
+
+      if (note.selector) {
+        lines.push(`- **Selector**: \`${note.selector}\``);
+      }
+      if (note.url) {
+        lines.push(`- **URL**: ${note.url}`);
+      }
+      if (note.tag || note.text_content) {
+        const parts: string[] = [];
+        if (note.tag) parts.push(`<${note.tag}>`);
+        if (note.text_content) parts.push(`"${note.text_content}"`);
+        lines.push(`- **Element**: ${parts.join(' ')}`);
+      }
+      if (note.created_at) {
+        const reported = note.created_at.split('T')[0];
+        lines.push(`- **Reported**: ${reported}`);
+      }
+
+      // Full body as blockquote
+      if (note.body) {
+        const bodyLines = note.body.split('\n').map(l => `> ${l}`);
+        lines.push(bodyLines.join('\n'));
+      }
+
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
+}
+
+function formatAsXML(
+  grouped: Map<string, Note[]>,
+  total: number,
+  projectName: string,
+  date: string,
+  resolvedNotes?: Map<string, ResolvedNote>,
+): string {
+  const lines: string[] = [];
+
+  lines.push(`<ui-notes project="${escapeXml(projectName)}" count="${total}" date="${date}">`);
+
+  for (const [component, notes] of grouped) {
+    const compName = component === '_unresolved' ? '_unresolved' : component;
+    lines.push(`  <component name="${escapeXml(compName)}" count="${notes.length}">`);
+
+    for (const note of notes) {
+      const typeAttr = (note.type || 'note').toLowerCase();
+      lines.push(`    <note type="${escapeXml(typeAttr)}" id="${escapeXml(note.id)}">`);
+      lines.push(`      <body>${escapeXml(note.body || '')}</body>`);
+
+      // File resolution output
+      if (resolvedNotes) {
+        const resolved = resolvedNotes.get(note.id);
+        if (resolved && resolved.files.length > 0) {
+          lines.push(`      <resolved-files>`);
+          for (const file of resolved.files) {
+            const loc = file.lineNumber ? `${file.filePath}:${file.lineNumber}` : file.filePath;
+            lines.push(`        <file path="${escapeXml(loc)}" confidence="${file.confidence}" match-type="${file.matchType}" matched-on="${escapeXml(file.matchedOn)}" />`);
+          }
+          lines.push(`      </resolved-files>`);
+        }
+      }
+
+      if (note.selector) {
+        lines.push(`      <selector>${escapeXml(note.selector)}</selector>`);
+      }
+      if (note.url) {
+        lines.push(`      <url>${escapeXml(note.url)}</url>`);
+      }
+      if (note.tag) {
+        lines.push(`      <tag>${escapeXml(note.tag)}</tag>`);
+      }
+      if (note.text_content) {
+        lines.push(`      <text-content>${escapeXml(note.text_content)}</text-content>`);
+      }
+      if (note.created_at) {
+        lines.push(`      <created>${note.created_at.split('T')[0]}</created>`);
+      }
+      lines.push(`    </note>`);
+    }
+
+    lines.push(`  </component>`);
+  }
+
+  lines.push(`</ui-notes>`);
+  return lines.join('\n') + '\n';
+}
+
+function formatAsJSON(
+  grouped: Map<string, Note[]>,
+  total: number,
+  projectName: string,
+  date: string,
+  resolvedNotes?: Map<string, ResolvedNote>,
+): string {
+  const components: Record<string, unknown[]> = {};
+
+  for (const [component, notes] of grouped) {
+    components[component] = notes.map(n => {
+      const entry: Record<string, unknown> = {
+        id: n.id,
+        type: n.type,
+        body: n.body,
+        selector: n.selector || undefined,
+        url: n.url || undefined,
+        tag: n.tag || undefined,
+        text_content: n.text_content || undefined,
+        created_at: n.created_at,
+      };
+
+      if (resolvedNotes) {
+        const resolved = resolvedNotes.get(n.id);
+        entry.resolved_files = resolved?.files || [];
+      }
+
+      return entry;
+    });
+  }
+
+  const output = {
+    project: projectName,
+    total,
+    date,
+    components,
+  };
+
+  return JSON.stringify(output, null, 2) + '\n';
+}
+
+function escapeXml(str: string): string {
+  return str
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}

package/index.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env bun
 
 import { getConfig } from './config.js';
 import { configShow, configSet } from './commands/config.js';
@@ -6,6 +6,8 @@ import { listProjects, createProject, updateProject, deleteProject, getProject,
 import { pull } from './commands/pull.js';
 import { resolve, wontfix } from './commands/resolve.js';
 import { login } from './commands/login.js';
+import { comment, listComments } from './commands/comment.js';
+import { context } from './commands/context.js';
 
 const HELP = `uinotes - CLI for UI Notes
 
@@ -22,15 +24,30 @@ Commands:
   projects delete <slug>                Archive a project
   login                                 Login and create API key
   pull                                  Fetch open notes
+  context                               AI-optimized digest of open notes
   resolve <id>                          Mark note as resolved
   wontfix <id>                          Mark note as won't fix
+  comment <id> "text"                   Add a comment to a note
+  comments <id>                         List comments for a note
+  resolve-by-component <name> [msg]     Bulk resolve notes by component
+  resolve-by-selector <sel> [msg]       Bulk resolve notes by selector
+  visual-diff                           Capture & compare page screenshots
   config                                View/edit configuration
 
 Options:
   --help, -h        Show help
   --project <name>  Override project for this request
   --archived        Include archived projects in list
-  --url <pattern>   URL pattern for project create (repeatable)`;
+  --url <pattern>   URL pattern for project create (repeatable)
+  --format <fmt>    Output format for context: markdown (default), xml, json
+  --component <n>   Filter notes by component name (context command)
+  --status <s>      Filter notes by status (default: open)
+  --type <t>        Filter notes by type
+  --resolve-files   Resolve notes to source files (pull, context)
+  --root-dir <dir>  Source root for file resolution (default: cwd)
+  --compare         Compare current screenshots against previous (visual-diff)
+  --width <px>      Viewport width for screenshots (default: 1280)
+  --full-page       Capture full page height (default: true)`;
 
 function parseFlags(args: string[]): { flags: Record<string, string>; arrays: Record<string, string[]>; positional: string[] } {
   const flags: Record<string, string> = {};
@@ -195,6 +212,21 @@ async function main() {
         status: flags.status,
         type: flags.type,
         limit: flags.limit,
+        resolveFiles: flags['resolve-files'] === 'true',
+        rootDir: flags['root-dir'],
+      });
+      break;
+
+    case 'context':
+      await context(config, {
+        project,
+        type: flags.type,
+        status: flags.status,
+        component: flags.component,
+        format: (flags.format as 'markdown' | 'xml' | 'json') || undefined,
+        limit: flags.limit,
+        resolveFiles: flags['resolve-files'] === 'true',
+        rootDir: flags['root-dir'],
       });
       break;
 
@@ -218,6 +250,73 @@ async function main() {
       break;
     }
 
+    case 'comment': {
+      const id = positional[1];
+      const body = positional.slice(2).join(' ');
+      if (!id || !body) {
+        console.error('Usage: uinotes comment <note-id> "comment text"');
+        process.exit(1);
+      }
+      await comment(config, id, body, project);
+      break;
+    }
+
+    case 'comments': {
+      const id = positional[1];
+      if (!id) {
+        console.error('Usage: uinotes comments <note-id>');
+        process.exit(1);
+      }
+      await listComments(config, id, project);
+      break;
+    }
+
+    case 'resolve-by-component': {
+      const name = positional[1];
+      if (!name) {
+        console.error('Usage: uinotes resolve-by-component <component-name> [--message "text"]');
+        process.exit(1);
+      }
+      const { resolveByComponent } = await import('./commands/bulk-resolve.js');
+      await resolveByComponent(config, name, {
+        project,
+        message: flags.message || positional.slice(2).join(' ') || undefined,
+        dryRun: flags['dry-run'] === 'true',
+        force: flags.force === 'true',
+        status: flags.wontfix === 'true' ? 'wontfix' : 'resolved',
+      });
+      break;
+    }
+
+    case 'visual-diff': {
+      const { visualDiff } = await import('./commands/visual-diff.js');
+      await visualDiff(config, {
+        project,
+        url: flags.url,
+        compare: flags.compare === 'true',
+        width: flags.width ? parseInt(flags.width) : undefined,
+        fullPage: flags['full-page'] !== 'false',
+      });
+      break;
+    }
+
+    case 'resolve-by-selector': {
+      const sel = positional[1];
+      if (!sel) {
+        console.error('Usage: uinotes resolve-by-selector <selector> [--message "text"]');
+        process.exit(1);
+      }
+      const { resolveBySelector } = await import('./commands/bulk-resolve.js');
+      await resolveBySelector(config, sel, {
+        project,
+        message: flags.message || positional.slice(2).join(' ') || undefined,
+        dryRun: flags['dry-run'] === 'true',
+        force: flags.force === 'true',
+        status: flags.wontfix === 'true' ? 'wontfix' : 'resolved',
+      });
+      break;
+    }
+
     default:
       console.error(`Unknown command: ${command}`);
       console.error('Run uinotes --help for usage');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@upgraide/ui-notes-cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "CLI for UI Notes - pull and manage UI feedback notes",
   "license": "MIT",
   "keywords": ["cli", "ui", "notes", "feedback", "ui-notes"],
@@ -9,7 +9,9 @@
   },
   "files": [
     "*.ts",
-    "commands/*.ts"
+    "commands/*.ts",
+    "formatters/*.ts",
+    "resolvers/*.ts"
   ],
   "engines": {
     "bun": ">=1.0.0"