feedbackbasket-cli 0.3.0

package/dist/src/client.js

@@ -0,0 +1,133 @@
+import axios, { AxiosError } from 'axios';
+import { USER_AGENT } from './version.js';
+import { errAuth, errForbidden, errRateLimit, errNetwork, errAPI } from './output/errors.js';
+export class FeedbackBasketClient {
+    http;
+    constructor(token, baseUrl) {
+        this.http = axios.create({
+            baseURL: `${baseUrl}/api/v1`,
+            timeout: 30_000,
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                'User-Agent': USER_AGENT,
+            },
+        });
+    }
+    async me() {
+        return this.request('GET', '/auth/me');
+    }
+    async listProjects() {
+        return this.request('GET', '/projects');
+    }
+    async getProject(id) {
+        return this.request('GET', `/projects/${encodeURIComponent(id)}`);
+    }
+    async createProject(data) {
+        return this.request('POST', '/projects', data);
+    }
+    async updateProject(id, data) {
+        return this.request('PATCH', `/projects/${encodeURIComponent(id)}`, data);
+    }
+    async deleteProject(id) {
+        return this.request('DELETE', `/projects/${encodeURIComponent(id)}`);
+    }
+    async getFeedback(params = {}) {
+        const query = buildQuery(params);
+        return this.request('GET', `/feedback${query}`);
+    }
+    async getFeedbackById(id) {
+        return this.request('GET', `/feedback/${encodeURIComponent(id)}`);
+    }
+    async getBugReports(params = {}) {
+        const query = buildQuery(params);
+        return this.request('GET', `/feedback/bugs${query}`);
+    }
+    async getBugStats(params = {}) {
+        const query = params.projectId ? `?projectId=${encodeURIComponent(params.projectId)}` : '';
+        return this.request('GET', `/feedback/bugs/stats${query}`);
+    }
+    async searchFeedback(query, opts = {}) {
+        return this.getFeedback({ search: query, ...opts });
+    }
+    // Widget
+    async getWidgetSettings(projectId) {
+        return this.request('GET', `/projects/${encodeURIComponent(projectId)}/widget`);
+    }
+    async updateWidgetSettings(projectId, settings) {
+        return this.request('PATCH', `/projects/${encodeURIComponent(projectId)}/widget`, settings);
+    }
+    async getWidgetScript(projectId) {
+        return this.request('GET', `/projects/${encodeURIComponent(projectId)}/widget-script`);
+    }
+    // Write operations
+    async updateFeedback(id, data) {
+        return this.request('PATCH', `/feedback/${encodeURIComponent(id)}`, data);
+    }
+    async createNote(feedbackId, content) {
+        return this.request('POST', `/feedback/${encodeURIComponent(feedbackId)}/notes`, { content });
+    }
+    async deleteFeedback(id) {
+        return this.request('DELETE', `/feedback/${encodeURIComponent(id)}`);
+    }
+    async bulkUpdateStatus(ids, status) {
+        return this.request('POST', '/feedback/bulk-update', { ids, status });
+    }
+    async updateNote(feedbackId, noteId, content) {
+        return this.request('PATCH', `/feedback/${encodeURIComponent(feedbackId)}/notes/${encodeURIComponent(noteId)}`, { content });
+    }
+    async deleteNote(feedbackId, noteId) {
+        return this.request('DELETE', `/feedback/${encodeURIComponent(feedbackId)}/notes/${encodeURIComponent(noteId)}`);
+    }
+    async exportFeedback(projectId, format = 'csv') {
+        const response = await this.http.get(`/projects/${encodeURIComponent(projectId)}/export?format=${format}`);
+        return typeof response.data === 'string' ? response.data : JSON.stringify(response.data, null, 2);
+    }
+    // Team
+    async listTeam() {
+        return this.request('GET', '/team');
+    }
+    async updateMemberRole(memberId, role) {
+        return this.request('PATCH', `/team/${encodeURIComponent(memberId)}`, { role });
+    }
+    async removeMember(memberId) {
+        return this.request('DELETE', `/team/${encodeURIComponent(memberId)}`);
+    }
+    async request(method, path, data) {
+        try {
+            const response = await this.http.request({ method, url: path, data });
+            return response.data;
+        }
+        catch (error) {
+            throw this.handleError(error);
+        }
+    }
+    handleError(error) {
+        if (error instanceof AxiosError) {
+            const status = error.response?.status;
+            const message = error.response?.data?.error
+                ?? error.response?.data?.message
+                ?? error.message;
+            if (!error.response) {
+                return errNetwork(error);
+            }
+            switch (status) {
+                case 401: return errAuth(message);
+                case 403: return errForbidden(message);
+                case 404: return errAPI(404, message);
+                case 429: return errRateLimit();
+                default: return errAPI(status ?? 500, message);
+            }
+        }
+        return error instanceof Error ? error : new Error(String(error));
+    }
+}
+function buildQuery(params) {
+    const parts = [];
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null) {
+            parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+        }
+    }
+    return parts.length > 0 ? `?${parts.join('&')}` : '';
+}

package/dist/src/commands/auth.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+import type { OutputWriter } from '../output/writer.js';
+export declare function createAuthCommand(getWriter: () => OutputWriter): Command;
+export declare function createLoginCommand(getWriter: () => OutputWriter): Command;
+export declare function createLogoutCommand(getWriter: () => OutputWriter): Command;

package/dist/src/commands/auth.js

@@ -0,0 +1,313 @@
+import { Command } from 'commander';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { AuthManager } from '../auth/manager.js';
+import { browserLogin } from '../auth/login.js';
+import { saveCredentials } from '../config/credentials.js';
+import { loadConfig, saveConfig } from '../config/config.js';
+import { FeedbackBasketClient } from '../client.js';
+import { errAuth, errUsage } from '../output/errors.js';
+import { brand, divider, logo } from '../output/theme.js';
+import { select, confirm } from '../prompt.js';
+export function createAuthCommand(getWriter) {
+    const auth = new Command('auth')
+        .description('Manage authentication');
+    // --- auth login ---
+    auth
+        .command('login')
+        .description('Authenticate with FeedbackBasket')
+        .option('--token <token>', 'Use an API token directly (for CI/headless)')
+        .option('--scope <scope>', 'Access scope: read or full', 'full')
+        .action(async (opts) => {
+        const writer = getWriter();
+        const config = loadConfig();
+        const scope = opts.scope === 'read' ? 'read' : 'full';
+        const isInteractive = !writer.isMachineOutput() && process.stdin.isTTY;
+        // ── Step 1: Authentication ──
+        if (isInteractive) {
+            console.log();
+            console.log(`  ${logo()} CLI`);
+            console.log();
+            console.log(brand.muted(`  Step 1: Authentication`));
+            console.log();
+        }
+        let token;
+        if (opts.token) {
+            token = opts.token;
+        }
+        else {
+            const result = await browserLogin(config.baseUrl, scope);
+            token = result.token;
+        }
+        // Verify token + get profile
+        const client = new FeedbackBasketClient(token, config.baseUrl);
+        let email;
+        let userId;
+        let organizationId;
+        try {
+            const profile = await client.me();
+            email = profile.email;
+            userId = profile.id;
+            organizationId = profile.organizationId;
+        }
+        catch (err) {
+            if (isInteractive) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.log(brand.warning(`  Could not verify token: ${msg}`));
+                console.log(brand.muted('  Token saved — run feedbackbasket doctor to diagnose'));
+                console.log();
+            }
+        }
+        saveCredentials({
+            token,
+            scope,
+            userId,
+            email,
+            organizationId,
+            createdAt: new Date().toISOString(),
+        });
+        if (isInteractive) {
+            console.log(`  ${brand.success('✓')} Authentication successful`);
+            if (email)
+                console.log(`    ${brand.muted('Logged in as')} ${brand.bold(email)}`);
+            console.log();
+        }
+        // ── Step 2: Default Project (interactive only, first login) ──
+        let defaultProjectName;
+        if (isInteractive && !config.defaultProject) {
+            console.log();
+            console.log(brand.muted(`  Step 2: Default Project (optional)`));
+            console.log();
+            try {
+                const projectsRes = await client.listProjects();
+                const projects = projectsRes.projects;
+                if (projects.length === 0) {
+                    console.log(brand.muted('  No projects found. Create one from the dashboard.'));
+                    console.log();
+                }
+                else if (projects.length === 1) {
+                    // Auto-select single project
+                    const p = projects[0];
+                    config.defaultProject = p.id;
+                    saveConfig(config);
+                    defaultProjectName = p.name;
+                    console.log(`  ${brand.success('✓')} Default project: ${brand.bold(p.name)}`);
+                    console.log(`    ${brand.muted('Only project in your organization')}`);
+                    console.log();
+                }
+                else {
+                    console.log(`  You have ${brand.bold(String(projects.length))} projects:\n`);
+                    const choice = await select('Select default project', projects.map(p => {
+                        const count = brand.muted(`(${p.totalFeedback} feedback)`);
+                        return `${p.name} ${count}`;
+                    }));
+                    if (choice !== null) {
+                        const p = projects[choice];
+                        config.defaultProject = p.id;
+                        saveConfig(config);
+                        defaultProjectName = p.name;
+                        console.log();
+                        console.log(`  ${brand.success('✓')} Default project: ${brand.bold(p.name)}`);
+                        console.log(`    ${brand.muted('Use --project to override per-command')}`);
+                    }
+                    else {
+                        console.log();
+                        console.log(`  ${brand.muted('Skipped. Use --project or: feedbackbasket config set defaultProject <id>')}`);
+                    }
+                    console.log();
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.log(brand.muted(`  Could not fetch projects: ${msg}`));
+                console.log(brand.muted('  You can set a default later: feedbackbasket config set defaultProject <id>'));
+                console.log();
+            }
+        }
+        // ── Step 3: Agent Setup (interactive only) ──
+        let agentInstalled = false;
+        if (isInteractive) {
+            const claudeDir = join(homedir(), '.claude');
+            const skillPath = join(claudeDir, 'skills', 'feedbackbasket', 'SKILL.md');
+            const claudeExists = existsSync(claudeDir);
+            const skillExists = existsSync(skillPath);
+            if (claudeExists && !skillExists) {
+                console.log();
+                console.log(brand.muted(`  Step 3: Agent Setup`));
+                console.log();
+                console.log(`  ${brand.primary('Detected:')} Claude Code`);
+                console.log();
+                console.log(`  This will:`);
+                console.log(`    1. Install FeedbackBasket skill to ~/.claude/skills/`);
+                console.log();
+                const doSetup = await confirm('  Set up for Claude Code?');
+                if (doSetup) {
+                    try {
+                        const { mkdirSync, copyFileSync } = await import('node:fs');
+                        const { dirname } = await import('node:path');
+                        const { fileURLToPath } = await import('node:url');
+                        const thisDir = dirname(fileURLToPath(import.meta.url));
+                        const projectRoot = join(thisDir, '..', '..', '..');
+                        let skillSrc = join(projectRoot, 'skills', 'feedbackbasket', 'SKILL.md');
+                        if (!existsSync(skillSrc)) {
+                            skillSrc = join(thisDir, '..', '..', 'skills', 'feedbackbasket', 'SKILL.md');
+                        }
+                        if (existsSync(skillSrc)) {
+                            const skillDir = join(claudeDir, 'skills', 'feedbackbasket');
+                            mkdirSync(skillDir, { recursive: true });
+                            copyFileSync(skillSrc, skillPath);
+                            agentInstalled = true;
+                            console.log(`  ${brand.success('✓')} Agent skill installed`);
+                        }
+                        else {
+                            console.log(`  ${brand.error('✗')} SKILL.md not found in package`);
+                        }
+                    }
+                    catch {
+                        console.log(`  ${brand.error('✗')} Failed to install skill`);
+                    }
+                }
+                else {
+                    console.log(brand.muted('  Skipped. Run later: feedbackbasket setup claude'));
+                }
+                console.log();
+            }
+            else if (claudeExists && skillExists) {
+                agentInstalled = true;
+            }
+        }
+        // ── Summary ──
+        if (isInteractive) {
+            console.log();
+            console.log(divider(35));
+            console.log(brand.bold('  Setup complete!'));
+            console.log(divider(35));
+            console.log();
+            console.log(`  ${brand.success('✓')} Authenticated${email ? ` as ${email}` : ''}`);
+            if (defaultProjectName) {
+                console.log(`  ${brand.success('✓')} Default project: ${defaultProjectName}`);
+            }
+            else if (config.defaultProject) {
+                console.log(`  ${brand.success('✓')} Default project: ${config.defaultProject}`);
+            }
+            else {
+                console.log(`  ${brand.muted('-')} No default project`);
+            }
+            if (agentInstalled) {
+                console.log(`  ${brand.success('✓')} Claude Code skill`);
+            }
+            console.log();
+            console.log('  Try these commands:');
+            console.log();
+            console.log(`    ${brand.command('feedbackbasket projects list')}     List your projects`);
+            console.log(`    ${brand.command('feedbackbasket feedback list')}     View recent feedback`);
+            console.log(`    ${brand.command('feedbackbasket bugs list')}         View bug reports`);
+            console.log(`    ${brand.command('feedbackbasket doctor')}            Run diagnostics`);
+            console.log();
+            return; // Skip the JSON output in interactive wizard mode
+        }
+        // Machine output
+        writer.ok({ authenticated: true, email, scope, defaultProject: config.defaultProject }, {
+            summary: email ? `Logged in as ${email}` : 'Authenticated successfully',
+            breadcrumbs: [
+                { action: 'List projects', cmd: 'feedbackbasket projects list' },
+                { action: 'Check status', cmd: 'feedbackbasket auth status' },
+                { action: 'Run diagnostics', cmd: 'feedbackbasket doctor' },
+            ],
+        });
+    });
+    // --- auth logout ---
+    auth
+        .command('logout')
+        .description('Clear stored credentials')
+        .action(() => {
+        const writer = getWriter();
+        const manager = new AuthManager();
+        if (!manager.isAuthenticated()) {
+            writer.ok({ authenticated: false }, { summary: 'Already logged out' });
+            return;
+        }
+        if (manager.getSource() === 'env') {
+            throw errUsage('Credentials are set via FEEDBACKBASKET_TOKEN environment variable', 'Unset the variable: unset FEEDBACKBASKET_TOKEN');
+        }
+        manager.logout();
+        if (!writer.isMachineOutput()) {
+            console.log(`  ${brand.success('✓')} Logged out`);
+            console.log();
+        }
+        writer.ok({ authenticated: false }, {
+            summary: 'Logged out',
+            breadcrumbs: [
+                { action: 'Log back in', cmd: 'feedbackbasket auth login' },
+            ],
+        });
+    });
+    // --- auth status ---
+    auth
+        .command('status')
+        .description('Show authentication status')
+        .action(() => {
+        const writer = getWriter();
+        const manager = new AuthManager();
+        const creds = manager.getCredentials();
+        if (!creds) {
+            throw errAuth('Not authenticated');
+        }
+        const config = loadConfig();
+        const data = {
+            authenticated: true,
+            source: manager.getSource(),
+            token: manager.getTokenPreview(),
+            scope: creds.scope,
+            email: creds.email ?? null,
+            organizationId: creds.organizationId ?? null,
+            defaultProject: config.defaultProject ?? null,
+        };
+        writer.ok(data, {
+            summary: `Authenticated${creds.email ? ` as ${creds.email}` : ''}`,
+            breadcrumbs: [
+                { action: 'List projects', cmd: 'feedbackbasket projects list' },
+                { action: 'Log out', cmd: 'feedbackbasket auth logout' },
+            ],
+        });
+    });
+    // --- auth token ---
+    auth
+        .command('token')
+        .description('Print the current access token (for scripting)')
+        .action(() => {
+        const manager = new AuthManager();
+        const token = manager.resolveToken();
+        if (!token) {
+            throw errAuth('Not authenticated');
+        }
+        process.stdout.write(token);
+    });
+    return auth;
+}
+// Top-level aliases: `feedbackbasket login` and `feedbackbasket logout`
+export function createLoginCommand(getWriter) {
+    return new Command('login')
+        .description('Authenticate with FeedbackBasket (alias for auth login)')
+        .option('--token <token>', 'Use an API token directly (for CI/headless)')
+        .option('--scope <scope>', 'Access scope: read or full', 'full')
+        .action(async (opts) => {
+        // Delegate to auth login by re-parsing
+        const authCmd = createAuthCommand(getWriter);
+        const args = ['node', 'feedbackbasket', 'login'];
+        if (opts.token)
+            args.push('--token', opts.token);
+        if (opts.scope)
+            args.push('--scope', opts.scope);
+        await authCmd.parseAsync(args);
+    });
+}
+export function createLogoutCommand(getWriter) {
+    return new Command('logout')
+        .description('Clear stored credentials (alias for auth logout)')
+        .action(async () => {
+        const authCmd = createAuthCommand(getWriter);
+        await authCmd.parseAsync(['node', 'feedbackbasket', 'logout']);
+    });
+}

package/dist/src/commands/bugs.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { OutputWriter } from '../output/writer.js';
+export declare function createBugsCommand(getWriter: () => OutputWriter): Command;

package/dist/src/commands/bugs.js

@@ -0,0 +1,120 @@
+import { Command } from 'commander';
+import { FeedbackBasketClient } from '../client.js';
+import { AuthManager } from '../auth/manager.js';
+import { loadConfig } from '../config/config.js';
+import { errAuth } from '../output/errors.js';
+import { brand, divider } from '../output/theme.js';
+function resolveProjectId(optProject) {
+    if (optProject)
+        return optProject;
+    const config = loadConfig();
+    return config.defaultProject;
+}
+export function createBugsCommand(getWriter) {
+    const bugs = new Command('bugs')
+        .description('View bug reports');
+    bugs
+        .command('list')
+        .description('List bug reports with severity classification')
+        .option('--project <id>', 'Filter by project ID')
+        .option('--severity <level>', 'Filter by severity (high, medium, low)')
+        .option('--status <status>', 'Filter by status')
+        .option('--search <query>', 'Search bug content')
+        .option('--limit <n>', 'Max results (1-100)', '20')
+        .option('--offset <n>', 'Offset for pagination', '0')
+        .option('--notes', 'Include internal notes')
+        .action(async (opts) => {
+        const writer = getWriter();
+        const client = requireClient();
+        const result = await client.getBugReports({
+            projectId: resolveProjectId(opts.project),
+            status: opts.status,
+            severity: opts.severity,
+            search: opts.search,
+            limit: parseInt(opts.limit, 10),
+            offset: parseInt(opts.offset, 10),
+            includeNotes: opts.notes ?? false,
+        });
+        if (!writer.isMachineOutput()) {
+            renderBugStats(result.stats);
+            console.log();
+            renderBugList(result.bugReports);
+        }
+        const breadcrumbs = [];
+        if (!opts.severity) {
+            breadcrumbs.push({ action: 'High severity only', cmd: `feedbackbasket bugs list --severity high${opts.project ? ` --project ${opts.project}` : ''}` });
+        }
+        if (result.pagination.hasMore) {
+            const nextOffset = parseInt(opts.offset, 10) + parseInt(opts.limit, 10);
+            breadcrumbs.push({ action: 'Next page', cmd: `feedbackbasket bugs list --offset ${nextOffset}${opts.project ? ` --project ${opts.project}` : ''}` });
+        }
+        breadcrumbs.push({ action: 'All feedback', cmd: 'feedbackbasket feedback list' });
+        writer.ok(result.bugReports, {
+            summary: `${result.stats.total} bug${result.stats.total === 1 ? '' : 's'} (${result.stats.bySeverity.high} high, ${result.stats.bySeverity.medium} medium, ${result.stats.bySeverity.low} low)`,
+            notice: result.pagination.hasMore ? `Showing ${result.bugReports.length} of ${result.pagination.totalCount}` : undefined,
+            breadcrumbs,
+        });
+    });
+    bugs
+        .command('stats')
+        .description('Show bug statistics summary')
+        .option('--project <id>', 'Filter by project ID')
+        .action(async (opts) => {
+        const writer = getWriter();
+        const client = requireClient();
+        const stats = await client.getBugStats({ projectId: opts.project });
+        if (!writer.isMachineOutput()) {
+            renderBugStats(stats);
+        }
+        writer.ok(stats, {
+            summary: `${stats.total} total bugs`,
+            breadcrumbs: [
+                { action: 'List all bugs', cmd: 'feedbackbasket bugs list' },
+                { action: 'High severity', cmd: 'feedbackbasket bugs list --severity high' },
+            ],
+        });
+    });
+    return bugs;
+}
+function requireClient() {
+    const manager = new AuthManager();
+    const token = manager.resolveToken();
+    if (!token)
+        throw errAuth();
+    const config = loadConfig();
+    return new FeedbackBasketClient(token, config.baseUrl);
+}
+function renderBugStats(stats) {
+    console.log(brand.bold('Bug Summary'));
+    console.log(divider(30));
+    console.log(`  Total:   ${brand.bold(String(stats.total))}`);
+    console.log(`  ${brand.high('High')}:    ${stats.bySeverity.high}`);
+    console.log(`  ${brand.medium('Medium')}:  ${stats.bySeverity.medium}`);
+    console.log(`  ${brand.low('Low')}:     ${stats.bySeverity.low}`);
+    const statusEntries = Object.entries(stats.byStatus);
+    if (statusEntries.length > 0) {
+        console.log();
+        console.log(brand.bold('By Status'));
+        for (const [status, count] of statusEntries) {
+            console.log(`  ${status.padEnd(14)} ${count}`);
+        }
+    }
+}
+function renderBugList(bugs) {
+    if (bugs.length === 0) {
+        console.log(brand.muted('  No bug reports found'));
+        return;
+    }
+    const severityColor = { high: brand.high, medium: brand.medium, low: brand.low };
+    for (const bug of bugs) {
+        const sev = severityColor[bug.severity](`[${bug.severity.toUpperCase()}]`);
+        const status = brand.muted(`[${bug.status}]`);
+        const content = bug.content.length > 75 ? bug.content.slice(0, 72) + '...' : bug.content;
+        console.log(`${sev} ${status} ${brand.muted(bug.id)}`);
+        console.log(`  ${content}`);
+        if (bug.aiSummary) {
+            console.log(`  ${brand.hint(bug.aiSummary)}`);
+        }
+        console.log();
+    }
+}

package/dist/src/commands/doctor.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { OutputWriter } from '../output/writer.js';
+export declare function createDoctorCommand(getWriter: () => OutputWriter): Command;