@upgraide/ui-notes-cli 0.2.2 → 0.2.4

package/README.md

@@ -13,8 +13,9 @@ npm install -g @upgraide/ui-notes-cli
 ## Quick Start
 
 ```bash
-# Authenticate with your API server
-uinotes login
+# Configure your API key
+uinotes config set apiUrl https://my-api.example.com
+uinotes config set apiKey <your-key>
 
 # Pull open notes for your project
 uinotes pull --project my-app
@@ -25,16 +26,6 @@ uinotes resolve 42 "Fixed in latest deploy"
 
 ## Commands
 
-### `uinotes login`
-
-Interactive authentication flow. Prompts for your API URL, email, and password, then generates and saves an API key locally.
-
-```bash
-uinotes login
-```
-
-The API key is saved to `~/.uinotes.json` (or `.uinotes.json` in the current directory if one exists).
-
 ### `uinotes config`
 
 View or update configuration.

package/commands/install-skills.ts

@@ -1,5 +1,5 @@
 import type { Config } from '../config.js';
-import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from 'fs';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join } from 'path';
 
 interface InstallSkillsOptions {
@@ -8,51 +8,34 @@ interface InstallSkillsOptions {
 }
 
 const DEFAULT_DIR = '.claude/skills';
+const SKILL_FOLDER = 'ui-notes';
+const SKILL_FILE = 'SKILL.md';
 
 export async function installSkills(_config: Config, opts: InstallSkillsOptions): Promise<void> {
   const targetDir = opts.dir || join(process.cwd(), DEFAULT_DIR);
-  const skillsSourceDir = join(import.meta.dir, '..', 'skills');
-
-  // List available skills
-  let skillFiles: string[];
-  try {
-    skillFiles = readdirSync(skillsSourceDir).filter(f => f.endsWith('.md'));
-  } catch {
-    console.error('Could not read bundled skill files.');
-    process.exit(1);
-  }
+  const sourcePath = join(import.meta.dir, '..', 'skills', SKILL_FOLDER, SKILL_FILE);
 
-  if (skillFiles.length === 0) {
-    console.error('No skill files found in package.');
+  if (!existsSync(sourcePath)) {
+    console.error('Could not find bundled skill file.');
     process.exit(1);
   }
 
+  const targetFolder = join(targetDir, SKILL_FOLDER);
+  const targetPath = join(targetFolder, SKILL_FILE);
+
   if (opts.check) {
-    // Check installed vs bundled
-    console.log('Skill status:');
-    for (const file of skillFiles) {
-      const targetPath = join(targetDir, file);
-      if (existsSync(targetPath)) {
-        console.log(`  ${file}: installed`);
-      } else {
-        console.log(`  ${file}: not installed`);
-      }
+    if (existsSync(targetPath)) {
+      console.log(`  ${SKILL_FOLDER}/${SKILL_FILE}: installed`);
+    } else {
+      console.log(`  ${SKILL_FOLDER}/${SKILL_FILE}: not installed`);
     }
     return;
   }
 
-  // Install skills
-  mkdirSync(targetDir, { recursive: true });
+  mkdirSync(targetFolder, { recursive: true });
+  const content = readFileSync(sourcePath, 'utf-8');
+  writeFileSync(targetPath, content);
 
-  for (const file of skillFiles) {
-    const sourcePath = join(skillsSourceDir, file);
-    const targetPath = join(targetDir, file);
-    const content = readFileSync(sourcePath, 'utf-8');
-    writeFileSync(targetPath, content);
-  }
-
-  console.log(`Installed ${skillFiles.length} skills to ${targetDir}/`);
-  for (const file of skillFiles) {
-    console.log(`  ${file}`);
-  }
+  console.log(`Installed skill to ${targetFolder}/`);
+  console.log(`  ${SKILL_FOLDER}/${SKILL_FILE}`);
 }

package/index.ts

@@ -5,7 +5,6 @@ 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';
 import { comment, listComments } from './commands/comment.js';
 import { context } from './commands/context.js';
 
@@ -23,7 +22,6 @@ Commands:
   projects remove-url <slug> <pattern>  Remove URL pattern
   projects delete <slug>                Archive a project
   set project <slug>                    Bind project to current directory
-  login                                 Login and create API key
   pull                                  Fetch open notes
   context                               AI-optimized digest of open notes
   explain <id>                          Full context for a single note
@@ -103,13 +101,6 @@ async function main() {
 
   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];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@upgraide/ui-notes-cli",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "CLI for UI Notes - pull and manage UI feedback notes",
   "license": "MIT",
   "keywords": ["cli", "ui", "notes", "feedback", "ui-notes"],
@@ -13,7 +13,7 @@
     "formatters/*.ts",
     "resolvers/*.ts",
     "schemas/*.json",
-    "skills/*.md"
+    "skills/**/*.md"
   ],
   "engines": {
     "bun": ">=1.0.0"

package/skills/ui-notes/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: ui-notes
+description: CLI commands for managing UI feedback notes — pull context, resolve issues, add comments, generate changelogs, and batch triage.
+---
+
+# UI Notes CLI
+
+`uinotes` is the CLI for UI Notes. Use these commands to triage, resolve, and manage UI feedback notes from your terminal.
+
+## Configuration
+
+```bash
+uinotes config                          # Show current config
+uinotes config set apiUrl <url>         # Set API URL
+uinotes config set apiKey <key>         # Set API key
+uinotes set project <slug>              # Bind project to current directory
+```
+
+## Context
+
+Fetch an AI-optimized digest of open UI notes.
+
+### When to use
+- At the start of a task to understand what UI issues exist
+- Before making UI changes to check for related notes
+- When the user asks about UI bugs, feedback, or design issues
+
+```bash
+uinotes context --format markdown
+```
+
+Add `--resolve-files --root-dir .` to map notes to source files.
+Add `--type bug` to filter by type (bug, ux, feature, question).
+Add `--project <slug>` to target a specific project.
+
+## Explain
+
+Get full context for a single note including comments, history, and visual diffs.
+
+### When to use
+- When investigating a specific note before fixing it
+- When you need comments, history, or visual diff context
+- When triaging a single note
+
+```bash
+uinotes explain <note-id>
+uinotes explain <note-id> --format json
+```
+
+Returns: note body, type, status, component, selector, URL, screenshot URL, all comments, status history, and visual diffs.
+
+## Resolve
+
+Mark notes as resolved after fixing the issue they describe.
+
+### When to use
+- After fixing a bug, UX issue, or implementing a feature request described in a note
+- After verifying a fix addresses the feedback
+
+```bash
+# Resolve with a message explaining the fix
+uinotes resolve <note-id> "Fixed by updating the component"
+
+# Mark as won't fix with explanation
+uinotes wontfix <note-id> "Working as intended"
+
+# Bulk resolve all notes for a component
+uinotes resolve-by-component <ComponentName> --message "Refactored component"
+```
+
+Always include a resolution message describing what was done.
+
+## Comment
+
+Add comments to notes to document progress or communicate.
+
+### When to use
+- To document what was tried or what's blocking a fix
+- To ask clarifying questions about a note
+- To provide a status update before resolving
+
+```bash
+uinotes comment <note-id> "Comment text here"
+uinotes comments <note-id>  # List existing comments
+```
+
+## Changelog
+
+Generate a changelog from notes resolved since a git ref or date.
+
+### When to use
+- After resolving notes, to generate a summary for PR descriptions
+- For release notes listing UI fixes
+- To audit what was fixed in a time period
+
+```bash
+uinotes changelog --since HEAD~5
+uinotes changelog --since v1.2.0 --format conventional
+uinotes changelog --since 2026-02-01 --format json
+```
+
+Formats: `markdown` (default), `conventional` (conventional commits), `json`.
+
+## Batch
+
+Execute multiple operations (resolve, wontfix, comment, reopen) in one invocation.
+
+### When to use
+- After triaging multiple notes and deciding actions for each
+- When resolving several notes as part of a single fix
+- For bulk operations that span multiple notes
+
+```bash
+echo '{"op":"resolve","id":"abc123","message":"Fixed overflow"}
+{"op":"comment","id":"def456","text":"Needs design input"}
+{"op":"wontfix","id":"ghi789","message":"Deprecated component"}' | uinotes batch -
+```
+
+Operations: `resolve`, `wontfix`, `comment` (requires `text`), `reopen`.
+Add `--dry-run` to preview without executing.
+
+## Pull
+
+Fetch raw note data from the API.
+
+```bash
+uinotes pull
+uinotes pull --project my-app --status open --type bug --limit 50
+```
+
+| Option | Description |
+|--------|-------------|
+| `--project <name>` | Filter by project |
+| `--status <status>` | Filter by status (`open`, `resolved`, `wontfix`) |
+| `--type <type>` | Filter by type (`bug`, `ux`, `feature`, `question`) |
+| `--limit <n>` | Max number of results |
+| `--resolve-files` | Map notes to source files |
+
+## Projects
+
+Manage projects.
+
+```bash
+uinotes projects                              # List all projects
+uinotes projects create <slug> <name>         # Create a project
+uinotes projects get <slug>                   # Get project details
+uinotes projects rename <slug> <name>         # Rename a project
+uinotes projects add-url <slug> <pattern>     # Add URL pattern
+uinotes projects remove-url <slug> <pattern>  # Remove URL pattern
+uinotes projects delete <slug>                # Archive a project
+```
+
+## Visual Diff
+
+Capture and compare page screenshots.
+
+```bash
+uinotes visual-diff --url https://myapp.com --project my-app
+uinotes visual-diff --compare  # Compare against previous screenshots
+```

package/commands/login.ts

@@ -1,76 +0,0 @@
-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/skills/uinotes-batch.md

@@ -1,23 +0,0 @@
----
-name: uinotes-batch
-description: Execute multiple note operations in a single call using NDJSON. Use for bulk triage of multiple notes.
----
-
-# uinotes-batch
-
-Execute multiple operations (resolve, wontfix, comment, reopen) in one invocation.
-
-## When to use
-- After triaging multiple notes and deciding actions for each
-- When resolving several notes as part of a single fix
-- For bulk operations that span multiple notes
-
-## Command
-```bash
-echo '{"op":"resolve","id":"abc123","message":"Fixed overflow"}
-{"op":"comment","id":"def456","text":"Needs design input"}
-{"op":"wontfix","id":"ghi789","message":"Deprecated component"}' | uinotes batch -
-```
-
-Operations: `resolve`, `wontfix`, `comment` (requires `text`), `reopen`.
-Add `--dry-run` to preview without executing.

package/skills/uinotes-changelog.md

@@ -1,22 +0,0 @@
----
-name: uinotes-changelog
-description: Generate a changelog from resolved UI notes. Use after resolving notes to create release notes or PR descriptions.
----
-
-# uinotes-changelog
-
-Generate a changelog from notes resolved since a git ref or date.
-
-## When to use
-- After resolving notes, to generate a summary for PR descriptions
-- For release notes listing UI fixes
-- To audit what was fixed in a time period
-
-## Command
-```bash
-uinotes changelog --since HEAD~5
-uinotes changelog --since v1.2.0 --format conventional
-uinotes changelog --since 2026-02-01 --format json
-```
-
-Formats: `markdown` (default), `conventional` (conventional commits), `json`.

package/skills/uinotes-comment.md

@@ -1,19 +0,0 @@
----
-name: uinotes-comment
-description: Add a comment to a UI note. Use to document progress, ask questions, or provide status updates on notes.
----
-
-# uinotes-comment
-
-Add comments to notes to document progress or communicate.
-
-## When to use
-- To document what was tried or what's blocking a fix
-- To ask clarifying questions about a note
-- To provide a status update before resolving
-
-## Command
-```bash
-uinotes comment <note-id> "Comment text here"
-uinotes comments <note-id>  # List existing comments
-```

package/skills/uinotes-context.md

@@ -1,22 +0,0 @@
----
-name: uinotes-context
-description: Fetch AI-optimized context of open UI notes for the current project. Use when asked to check for UI bugs, feedback, or notes.
----
-
-# uinotes-context
-
-Run `uinotes context` to get a structured digest of all open UI notes.
-
-## When to use
-- At the start of a task to understand what UI issues exist
-- Before making UI changes to check for related notes
-- When the user asks about UI bugs, feedback, or design issues
-
-## Command
-```bash
-uinotes context --format markdown
-```
-
-Add `--resolve-files --root-dir .` to map notes to source files.
-Add `--type bug` to filter by type (bug, ux, feature, question).
-Add `--project <slug>` to target a specific project.

package/skills/uinotes-explain.md

@@ -1,21 +0,0 @@
----
-name: uinotes-explain
-description: Get full context for a single note including comments, history, and visual diffs. Use when investigating a specific note.
----
-
-# uinotes-explain
-
-Get fully-hydrated context for a single note in one call.
-
-## When to use
-- When investigating a specific note before fixing it
-- When you need comments, history, or visual diff context
-- When triaging a single note
-
-## Command
-```bash
-uinotes explain <note-id>
-uinotes explain <note-id> --format json
-```
-
-Returns: note body, type, status, component, selector, URL, screenshot URL, all comments, status history, and visual diffs.

package/skills/uinotes-resolve.md

@@ -1,26 +0,0 @@
----
-name: uinotes-resolve
-description: Mark a UI note as resolved after fixing it. Use after completing a fix for a UI issue.
----
-
-# uinotes-resolve
-
-Mark notes as resolved after fixing the issue they describe.
-
-## When to use
-- After fixing a bug, UX issue, or implementing a feature request described in a note
-- After verifying a fix addresses the feedback
-
-## Commands
-```bash
-# Resolve with a message explaining the fix
-uinotes resolve <note-id> "Fixed by updating the component"
-
-# Mark as won't fix with explanation
-uinotes wontfix <note-id> "Working as intended"
-
-# Bulk resolve all notes for a component
-uinotes resolve-by-component <ComponentName> --message "Refactored component"
-```
-
-Always include a resolution message describing what was done.