@upgraide/ui-notes-cli 0.1.0

package/api.ts

@@ -0,0 +1,36 @@
+import type { Config } from './config.js';
+
+export async function apiFetch(
+  config: Config,
+  path: string,
+  options: { method?: string; body?: unknown; project?: string } = {},
+): Promise<unknown> {
+  const { method = 'GET', body, project } = options;
+
+  const headers: Record<string, string> = {
+    'x-api-key': config.apiKey,
+  };
+
+  const targetProject = project || config.defaultProject;
+  if (targetProject) {
+    headers['x-project'] = targetProject;
+  }
+
+  if (body) {
+    headers['Content-Type'] = 'application/json';
+  }
+
+  const res = await fetch(`${config.apiUrl}${path}`, {
+    method,
+    headers,
+    body: body ? (typeof body === 'string' ? body : JSON.stringify(body)) : undefined,
+  });
+
+  const json = (await res.json()) as { ok: boolean; error?: string; data?: unknown };
+
+  if (!json.ok) {
+    throw new Error(json.error || `API error (${res.status})`);
+  }
+
+  return json;
+}

package/commands/config.ts

@@ -0,0 +1,31 @@
+import { getConfig, getConfigPath, setConfigValue } from '../config.js';
+
+const VALID_KEYS = ['apiUrl', 'apiKey', 'defaultProject'];
+
+function redactKey(value: string): string {
+  if (!value || value.length <= 4) return '****';
+  return value.slice(0, 4) + '****';
+}
+
+export function configShow(): void {
+  const config = getConfig();
+  const path = getConfigPath();
+  console.log(
+    JSON.stringify({
+      path,
+      config: {
+        ...config,
+        apiKey: redactKey(config.apiKey),
+      },
+    }),
+  );
+}
+
+export function configSet(key: string, value: string): void {
+  if (!VALID_KEYS.includes(key)) {
+    console.error(`Invalid config key: ${key}. Valid keys: ${VALID_KEYS.join(', ')}`);
+    process.exit(1);
+  }
+  const updated = setConfigValue(key, value);
+  console.log(JSON.stringify({ ok: true, key, value: key === 'apiKey' ? redactKey(value) : value }));
+}

package/commands/login.ts

@@ -0,0 +1,76 @@
+import type { Config } from '../config.js';
+import { setConfigValue } from '../config.js';
+
+export async function login(config: Config) {
+  const readline = await import('readline');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const ask = (q: string): Promise<string> =>
+    new Promise((resolve) => rl.question(q, resolve));
+
+  try {
+    const apiUrl = config.apiUrl || (await ask('API URL (default: http://localhost:3000): ')) || 'http://localhost:3000';
+    const email = await ask('Email: ');
+    const password = await ask('Password: ');
+
+    if (!email || !password) {
+      console.error('Email and password are required.');
+      process.exit(1);
+    }
+
+    // Sign in
+    const signInRes = await fetch(`${apiUrl}/api/auth/sign-in/email`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, password }),
+    });
+
+    if (!signInRes.ok) {
+      const err = await signInRes.json().catch(() => ({}));
+      console.error('Login failed:', (err as any).message || signInRes.statusText);
+      process.exit(1);
+    }
+
+    // Extract session cookie
+    const cookies = signInRes.headers.getSetCookie?.() || [];
+    const sessionCookie = cookies.find((c) => c.startsWith('better-auth.session_token='));
+
+    if (!sessionCookie) {
+      console.error('Login succeeded but no session token received.');
+      process.exit(1);
+    }
+
+    const cookieValue = sessionCookie.split(';')[0];
+
+    // Create an API key using the session
+    const keyName = `cli-${new Date().toISOString().slice(0, 10)}`;
+    const createKeyRes = await fetch(`${apiUrl}/api/auth/api-key/create`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Cookie: cookieValue,
+      },
+      body: JSON.stringify({ name: keyName, prefix: 'uin_' }),
+    });
+
+    if (!createKeyRes.ok) {
+      const err = await createKeyRes.json().catch(() => ({}));
+      console.error('Failed to create API key:', (err as any).message || createKeyRes.statusText);
+      process.exit(1);
+    }
+
+    const keyData = await createKeyRes.json() as { key?: string };
+    if (!keyData.key) {
+      console.error('Failed to create API key: no key in response');
+      process.exit(1);
+    }
+
+    // Save config
+    setConfigValue('apiUrl', apiUrl);
+    setConfigValue('apiKey', keyData.key);
+
+    console.log(JSON.stringify({ ok: true, message: 'Logged in and API key saved', keyName }));
+  } finally {
+    rl.close();
+  }
+}

package/commands/projects.ts

@@ -0,0 +1,135 @@
+import type { Config } from '../config.js';
+import { apiFetch } from '../api.js';
+
+interface Project {
+  slug: string;
+  name: string;
+  urlPatterns: string[];
+  createdAt: string;
+  archived?: boolean;
+}
+
+interface ProjectsResponse {
+  ok: boolean;
+  data: { projects: Project[] };
+}
+
+interface ProjectResponse {
+  ok: boolean;
+  data: Project;
+}
+
+export async function listProjects(config: Config, includeArchived = false): Promise<void> {
+  const url = includeArchived ? '/projects?archived=true' : '/projects';
+  const data = await apiFetch(config, url) as ProjectsResponse;
+  
+  if (!data.data?.projects?.length) {
+    console.log('No projects found. Create one with: uinotes projects create <slug> <name> --url <pattern>');
+    return;
+  }
+  
+  console.log('\nProjects:\n');
+  for (const p of data.data.projects) {
+    const archived = p.archived ? ' (archived)' : '';
+    console.log(`  ${p.slug}${archived}`);
+    console.log(`    Name: ${p.name}`);
+    if (p.urlPatterns?.length) {
+      console.log(`    URLs: ${p.urlPatterns.join(', ')}`);
+    }
+    console.log(`    Created: ${p.createdAt}\n`);
+  }
+}
+
+export async function createProject(config: Config, slug: string, name: string, urlPatterns: string[] = []): Promise<void> {
+  const data = await apiFetch(config, '/projects', {
+    method: 'POST',
+    body: JSON.stringify({ slug, name, urlPatterns }),
+  }) as ProjectResponse;
+  
+  console.log(`✓ Created project: ${data.data.slug}`);
+  console.log(`  Name: ${data.data.name}`);
+  if (data.data.urlPatterns?.length) {
+    console.log(`  URLs: ${data.data.urlPatterns.join(', ')}`);
+  }
+}
+
+export async function updateProject(
+  config: Config, 
+  slug: string, 
+  updates: { name?: string; archived?: boolean }
+): Promise<void> {
+  const data = await apiFetch(config, `/projects/${slug}`, {
+    method: 'PATCH',
+    body: JSON.stringify(updates),
+  }) as ProjectResponse;
+  
+  console.log(`✓ Updated project: ${data.data.slug}`);
+  if (updates.name) console.log(`  Name: ${data.data.name}`);
+  if (updates.archived !== undefined) {
+    console.log(`  Archived: ${data.data.archived}`);
+  }
+}
+
+export async function deleteProject(config: Config, slug: string): Promise<void> {
+  await apiFetch(config, `/projects/${slug}`, {
+    method: 'DELETE',
+  });
+  
+  console.log(`✓ Archived project: ${slug}`);
+}
+
+export async function getProject(config: Config, slug: string): Promise<void> {
+  const data = await apiFetch(config, `/projects/${slug}`) as ProjectResponse;
+  
+  console.log(`\nProject: ${data.data.slug}\n`);
+  console.log(`  Name: ${data.data.name}`);
+  if (data.data.urlPatterns?.length) {
+    console.log(`  URL patterns:`);
+    for (const p of data.data.urlPatterns) {
+      console.log(`    - ${p}`);
+    }
+  } else {
+    console.log(`  URL patterns: (none)`);
+  }
+  console.log(`  Created: ${data.data.createdAt}`);
+  console.log(`  Archived: ${data.data.archived || false}`);
+}
+
+export async function addUrlPattern(config: Config, slug: string, pattern: string): Promise<void> {
+  // First get current patterns
+  const current = await apiFetch(config, `/projects/${slug}`) as ProjectResponse;
+  const patterns = current.data.urlPatterns || [];
+  
+  if (patterns.includes(pattern)) {
+    console.log(`Pattern already exists: ${pattern}`);
+    return;
+  }
+  
+  patterns.push(pattern);
+  
+  const data = await apiFetch(config, `/projects/${slug}`, {
+    method: 'PATCH',
+    body: JSON.stringify({ urlPatterns: patterns }),
+  }) as ProjectResponse;
+  
+  console.log(`✓ Added URL pattern to ${slug}: ${pattern}`);
+  console.log(`  All patterns: ${data.data.urlPatterns?.join(', ')}`);
+}
+
+export async function removeUrlPattern(config: Config, slug: string, pattern: string): Promise<void> {
+  // First get current patterns
+  const current = await apiFetch(config, `/projects/${slug}`) as ProjectResponse;
+  const patterns = (current.data.urlPatterns || []).filter((p: string) => p !== pattern);
+  
+  const data = await apiFetch(config, `/projects/${slug}`, {
+    method: 'PATCH',
+    body: JSON.stringify({ urlPatterns: patterns }),
+  }) as ProjectResponse;
+  
+  console.log(`✓ Removed URL pattern from ${slug}: ${pattern}`);
+  if (data.data.urlPatterns?.length) {
+    console.log(`  Remaining: ${data.data.urlPatterns.join(', ')}`);
+  } else {
+    console.log(`  No patterns remaining`);
+  }
+}

package/commands/pull.ts

@@ -0,0 +1,22 @@
+import type { Config } from '../config.js';
+import { apiFetch } from '../api.js';
+
+interface PullOptions {
+  project?: string;
+  status?: string;
+  type?: string;
+  limit?: string;
+}
+
+export async function pull(config: Config, opts: PullOptions): Promise<void> {
+  const params = new URLSearchParams();
+  if (opts.status) params.set('status', opts.status);
+  if (opts.type) params.set('type', opts.type);
+  if (opts.limit) params.set('limit', opts.limit);
+
+  const qs = params.toString();
+  const path = `/notes${qs ? `?${qs}` : ''}`;
+
+  const data = await apiFetch(config, path, { project: opts.project });
+  console.log(JSON.stringify(data));
+}

package/commands/resolve.ts

@@ -0,0 +1,30 @@
+import type { Config } from '../config.js';
+import { apiFetch } from '../api.js';
+
+export async function resolve(
+  config: Config,
+  id: string,
+  message: string | undefined,
+  project?: string,
+): Promise<void> {
+  const data = await apiFetch(config, `/notes/${id}`, {
+    method: 'PATCH',
+    body: { status: 'resolved', resolution: message },
+    project,
+  });
+  console.log(JSON.stringify(data));
+}
+
+export async function wontfix(
+  config: Config,
+  id: string,
+  message: string | undefined,
+  project?: string,
+): Promise<void> {
+  const data = await apiFetch(config, `/notes/${id}`, {
+    method: 'PATCH',
+    body: { status: 'wontfix', resolution: message },
+    project,
+  });
+  console.log(JSON.stringify(data));
+}

package/config.ts

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+
+export interface Config {
+  apiUrl: string;
+  apiKey: string;
+  defaultProject?: string;
+}
+
+const GLOBAL_PATH = join(homedir(), '.uinotes.json');
+const LOCAL_PATH = join(process.cwd(), '.uinotes.json');
+
+const DEFAULT_CONFIG: Config = {
+  apiUrl: 'http://localhost:3000',
+  apiKey: '',
+};
+
+function readJsonFile(path: string): Config | null {
+  if (!existsSync(path)) return null;
+  return JSON.parse(readFileSync(path, 'utf-8'));
+}
+
+export function getConfigPath(): string {
+  if (existsSync(LOCAL_PATH)) return LOCAL_PATH;
+  return GLOBAL_PATH;
+}
+
+export function getConfig(): Config {
+  // Per-repo config takes priority
+  const local = readJsonFile(LOCAL_PATH);
+  if (local) return { ...DEFAULT_CONFIG, ...local };
+
+  const global = readJsonFile(GLOBAL_PATH);
+  if (global) return { ...DEFAULT_CONFIG, ...global };
+
+  // Create default global config
+  writeFileSync(GLOBAL_PATH, JSON.stringify(DEFAULT_CONFIG, null, 2) + '\n');
+  return DEFAULT_CONFIG;
+}
+
+export function setConfigValue(key: string, value: string): Config {
+  const path = getConfigPath();
+  const config = existsSync(path)
+    ? JSON.parse(readFileSync(path, 'utf-8'))
+    : { ...DEFAULT_CONFIG };
+
+  (config as any)[key] = value;
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(config, null, 2) + '\n');
+  return config;
+}

package/index.ts

@@ -0,0 +1,231 @@
+#!/usr/bin/env bun
+
+import { getConfig } from './config.js';
+import { configShow, configSet } from './commands/config.js';
+import { listProjects, createProject, updateProject, deleteProject, getProject, addUrlPattern, removeUrlPattern } from './commands/projects.js';
+import { pull } from './commands/pull.js';
+import { resolve, wontfix } from './commands/resolve.js';
+import { login } from './commands/login.js';
+
+const HELP = `uinotes - CLI for UI Notes
+
+Usage:
+  uinotes <command> [options]
+
+Commands:
+  projects                              List all projects
+  projects create <slug> <name>         Create a new project
+  projects get <slug>                   Get project details
+  projects rename <slug> <name>         Rename a project
+  projects add-url <slug> <pattern>     Add URL pattern to project
+  projects remove-url <slug> <pattern>  Remove URL pattern
+  projects delete <slug>                Archive a project
+  login                                 Login and create API key
+  pull                                  Fetch open notes
+  resolve <id>                          Mark note as resolved
+  wontfix <id>                          Mark note as won't fix
+  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)`;
+
+function parseFlags(args: string[]): { flags: Record<string, string>; arrays: Record<string, string[]>; positional: string[] } {
+  const flags: Record<string, string> = {};
+  const arrays: Record<string, string[]> = { url: [] };
+  const positional: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next && !next.startsWith('--')) {
+        // Repeatable flags go into arrays
+        if (key === 'url') {
+          arrays.url.push(next);
+        } else {
+          flags[key] = next;
+        }
+        i++;
+      } else {
+        flags[key] = 'true';
+      }
+    } else if (arg === '-h') {
+      flags['help'] = 'true';
+    } else {
+      positional.push(arg);
+    }
+  }
+
+  return { flags, arrays, positional };
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const { flags, arrays, positional } = parseFlags(args);
+
+  if (flags.help || positional.length === 0) {
+    console.log(HELP);
+    process.exit(0);
+  }
+
+  const command = positional[0];
+
+  // Login command doesn't need API key validation
+  if (command === 'login') {
+    const config = getConfig();
+    await login(config);
+    return;
+  }
+
+  // Config command doesn't need API key validation
+  if (command === 'config') {
+    const sub = positional[1];
+    if (sub === 'set') {
+      const key = positional[2];
+      const value = positional[3];
+      if (!key || !value) {
+        console.error('Usage: uinotes config set <key> <value>');
+        process.exit(1);
+      }
+      configSet(key, value);
+      return;
+    }
+    // Default to show
+    configShow();
+    return;
+  }
+
+  const config = getConfig();
+  if (!config.apiKey) {
+    console.error('No API key configured. Run: uinotes config set apiKey <your-key>');
+    process.exit(1);
+  }
+
+  const project = flags.project;
+
+  switch (command) {
+    case 'projects': {
+      const sub = positional[1];
+      
+      if (!sub) {
+        // List projects
+        await listProjects(config, flags.archived === 'true');
+        break;
+      }
+      
+      switch (sub) {
+        case 'create': {
+          const slug = positional[2];
+          const name = positional.slice(3).join(' ') || positional[3];
+          if (!slug || !name) {
+            console.error('Usage: uinotes projects create <slug> <name> [--url <pattern>...]');
+            process.exit(1);
+          }
+          await createProject(config, slug, name, arrays.url);
+          break;
+        }
+        
+        case 'get': {
+          const slug = positional[2];
+          if (!slug) {
+            console.error('Usage: uinotes projects get <slug>');
+            process.exit(1);
+          }
+          await getProject(config, slug);
+          break;
+        }
+        
+        case 'rename': {
+          const slug = positional[2];
+          const name = positional.slice(3).join(' ') || positional[3];
+          if (!slug || !name) {
+            console.error('Usage: uinotes projects rename <slug> <new-name>');
+            process.exit(1);
+          }
+          await updateProject(config, slug, { name });
+          break;
+        }
+        
+        case 'add-url': {
+          const slug = positional[2];
+          const pattern = positional[3];
+          if (!slug || !pattern) {
+            console.error('Usage: uinotes projects add-url <slug> <pattern>');
+            process.exit(1);
+          }
+          await addUrlPattern(config, slug, pattern);
+          break;
+        }
+        
+        case 'remove-url': {
+          const slug = positional[2];
+          const pattern = positional[3];
+          if (!slug || !pattern) {
+            console.error('Usage: uinotes projects remove-url <slug> <pattern>');
+            process.exit(1);
+          }
+          await removeUrlPattern(config, slug, pattern);
+          break;
+        }
+        
+        case 'delete': {
+          const slug = positional[2];
+          if (!slug) {
+            console.error('Usage: uinotes projects delete <slug>');
+            process.exit(1);
+          }
+          await deleteProject(config, slug);
+          break;
+        }
+        
+        default:
+          console.error(`Unknown projects subcommand: ${sub}`);
+          process.exit(1);
+      }
+      break;
+    }
+
+    case 'pull':
+      await pull(config, {
+        project,
+        status: flags.status,
+        type: flags.type,
+        limit: flags.limit,
+      });
+      break;
+
+    case 'resolve': {
+      const id = positional[1];
+      if (!id) {
+        console.error('Usage: uinotes resolve <id> [message]');
+        process.exit(1);
+      }
+      await resolve(config, id, positional[2], project);
+      break;
+    }
+
+    case 'wontfix': {
+      const id = positional[1];
+      if (!id) {
+        console.error('Usage: uinotes wontfix <id> [message]');
+        process.exit(1);
+      }
+      await wontfix(config, id, positional[2], project);
+      break;
+    }
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.error('Run uinotes --help for usage');
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@upgraide/ui-notes-cli",
+  "version": "0.1.0",
+  "description": "CLI for UI Notes - pull and manage UI feedback notes",
+  "license": "MIT",
+  "keywords": ["cli", "ui", "notes", "feedback", "ui-notes"],
+  "bin": {
+    "uinotes": "./index.ts"
+  },
+  "files": [
+    "*.ts",
+    "commands/*.ts"
+  ],
+  "engines": {
+    "bun": ">=1.0.0"
+  }
+}