feedbackbasket-cli 0.3.0

package/dist/src/commands/doctor.js

@@ -0,0 +1,130 @@
+import { Command } from 'commander';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { VERSION } from '../version.js';
+import { AuthManager } from '../auth/manager.js';
+import { loadConfig, configDir } from '../config/config.js';
+import { FeedbackBasketClient } from '../client.js';
+import { brand, divider, logo } from '../output/theme.js';
+export function createDoctorCommand(getWriter) {
+    return new Command('doctor')
+        .description('Run diagnostics to check CLI health')
+        .option('--verbose', 'Show detailed diagnostic output')
+        .action(async () => {
+        const writer = getWriter();
+        const checks = [];
+        // 1. CLI version
+        checks.push({
+            name: 'CLI version',
+            status: 'pass',
+            message: `v${VERSION}`,
+        });
+        // 2. Config directory
+        const dir = configDir();
+        checks.push({
+            name: 'Config directory',
+            status: existsSync(dir) ? 'pass' : 'warn',
+            message: existsSync(dir) ? dir : `${dir} (not created yet)`,
+            hint: !existsSync(dir) ? 'Will be created on first auth login' : undefined,
+        });
+        // 3. Authentication
+        const manager = new AuthManager();
+        const token = manager.resolveToken();
+        if (token) {
+            checks.push({
+                name: 'Authentication',
+                status: 'pass',
+                message: `Authenticated via ${manager.getSource()} (${manager.getTokenPreview()})`,
+            });
+        }
+        else {
+            checks.push({
+                name: 'Authentication',
+                status: 'fail',
+                message: 'Not authenticated',
+                hint: 'Run: feedbackbasket auth login',
+            });
+        }
+        // 4. API connectivity
+        if (token) {
+            const config = loadConfig();
+            const client = new FeedbackBasketClient(token, config.baseUrl);
+            try {
+                const start = Date.now();
+                await client.listProjects();
+                const elapsed = Date.now() - start;
+                checks.push({
+                    name: 'API connectivity',
+                    status: 'pass',
+                    message: `${config.baseUrl} (${elapsed}ms)`,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                checks.push({
+                    name: 'API connectivity',
+                    status: 'fail',
+                    message,
+                    hint: 'Check your internet connection and base URL',
+                });
+            }
+        }
+        else {
+            checks.push({
+                name: 'API connectivity',
+                status: 'skip',
+                message: 'Skipped (not authenticated)',
+            });
+        }
+        // 5. Claude Code integration
+        const claudeSkillPath = join(homedir(), '.claude', 'skills', 'feedbackbasket', 'SKILL.md');
+        if (existsSync(claudeSkillPath)) {
+            checks.push({
+                name: 'Claude Code skill',
+                status: 'pass',
+                message: 'Installed',
+            });
+        }
+        else {
+            checks.push({
+                name: 'Claude Code skill',
+                status: 'warn',
+                message: 'Not installed',
+                hint: 'Run: feedbackbasket setup claude',
+            });
+        }
+        // Render
+        if (!writer.isMachineOutput()) {
+            renderChecks(checks);
+        }
+        const passed = checks.filter(c => c.status === 'pass').length;
+        const failed = checks.filter(c => c.status === 'fail').length;
+        const warned = checks.filter(c => c.status === 'warn').length;
+        writer.ok({ checks, passed, failed, warned }, {
+            summary: `${passed} passed, ${failed} failed, ${warned} warnings`,
+            breadcrumbs: failed > 0
+                ? [{ action: 'Authenticate', cmd: 'feedbackbasket auth login' }]
+                : [{ action: 'List projects', cmd: 'feedbackbasket projects list' }],
+        });
+    });
+}
+const statusIcon = {
+    pass: brand.success('  ✓'),
+    fail: brand.error('  ✗'),
+    warn: brand.warning('  !'),
+    skip: brand.muted('  -'),
+};
+function renderChecks(checks) {
+    console.log(`${logo()} CLI Diagnostics`);
+    console.log(divider(40));
+    console.log();
+    for (const check of checks) {
+        const icon = statusIcon[check.status] ?? '  ?';
+        console.log(`${icon} ${brand.bold(check.name)}: ${check.message}`);
+        if (check.hint) {
+            console.log(`      ${brand.muted(check.hint)}`);
+        }
+    }
+    console.log();
+}

package/dist/src/commands/feedback-bulk-update.d.ts

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

package/dist/src/commands/feedback-bulk-update.js

@@ -0,0 +1,39 @@
+import { Command } from 'commander';
+import { FeedbackBasketClient } from '../client.js';
+import { AuthManager } from '../auth/manager.js';
+import { loadConfig } from '../config/config.js';
+import { errAuth, errUsage } from '../output/errors.js';
+import { brand } from '../output/theme.js';
+export function createFeedbackBulkUpdateCommand(getWriter) {
+    return new Command('bulk-update')
+        .description('Update status for multiple feedback items at once')
+        .requiredOption('--status <status>', 'New status (OPEN, UNDER_REVIEW, PLANNED, IN_PROGRESS, COMPLETE, CLOSED)')
+        .requiredOption('--ids <ids>', 'Comma-separated feedback IDs')
+        .action(async (opts) => {
+        const writer = getWriter();
+        const client = requireClient();
+        const ids = opts.ids.split(',').map((id) => id.trim()).filter(Boolean);
+        if (ids.length === 0) {
+            throw errUsage('At least one ID is required', 'Example: --ids id1,id2,id3');
+        }
+        const result = await client.bulkUpdateStatus(ids, opts.status);
+        if (!writer.isMachineOutput()) {
+            console.log(`  ${brand.success('✓')} Updated ${result.updated} feedback items to ${brand.bold(result.status)}`);
+            console.log();
+        }
+        writer.ok(result, {
+            summary: `Updated ${result.updated} items to ${result.status}`,
+            breadcrumbs: [
+                { action: 'List feedback', cmd: 'feedbackbasket feedback list' },
+            ],
+        });
+    });
+}
+function requireClient() {
+    const manager = new AuthManager();
+    const token = manager.resolveToken();
+    if (!token)
+        throw errAuth();
+    const config = loadConfig();
+    return new FeedbackBasketClient(token, config.baseUrl);
+}

package/dist/src/commands/feedback-delete.d.ts

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

package/dist/src/commands/feedback-delete.js

@@ -0,0 +1,45 @@
+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 } from '../output/theme.js';
+import { confirm } from '../prompt.js';
+export function createFeedbackDeleteCommand(getWriter) {
+    return new Command('delete')
+        .argument('<id>', 'Feedback ID to delete')
+        .description('Delete a feedback item')
+        .option('--yes', 'Skip confirmation prompt')
+        .action(async (id, opts) => {
+        const writer = getWriter();
+        const client = requireClient();
+        if (!opts.yes && !writer.isMachineOutput() && process.stdin.isTTY) {
+            console.log(`  ${brand.warning('Warning:')} This will permanently delete feedback ${brand.bold(id)}`);
+            console.log();
+            const confirmed = await confirm('  Delete this feedback?', false);
+            if (!confirmed) {
+                console.log(brand.muted('  Cancelled.'));
+                return;
+            }
+        }
+        const result = await client.deleteFeedback(id);
+        if (!writer.isMachineOutput()) {
+            console.log(`  ${brand.success('✓')} Deleted feedback ${id}`);
+            console.log();
+        }
+        writer.ok(result, {
+            summary: `Deleted feedback ${id}`,
+            breadcrumbs: [
+                { action: 'List feedback', cmd: 'feedbackbasket feedback list' },
+            ],
+        });
+    });
+}
+function requireClient() {
+    const manager = new AuthManager();
+    const token = manager.resolveToken();
+    if (!token)
+        throw errAuth();
+    const config = loadConfig();
+    return new FeedbackBasketClient(token, config.baseUrl);
+}

package/dist/src/commands/feedback-export.d.ts

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

package/dist/src/commands/feedback-export.js

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { FeedbackBasketClient } from '../client.js';
+import { AuthManager } from '../auth/manager.js';
+import { loadConfig } from '../config/config.js';
+import { errAuth, errUsage } from '../output/errors.js';
+import { resolveProject } from '../resolve.js';
+export function createFeedbackExportCommand(getWriter) {
+    return new Command('export')
+        .description('Export feedback to CSV, Markdown, or JSON')
+        .argument('[project]', 'Project ID or name')
+        .option('--format <format>', 'Export format: csv, md, json', 'csv')
+        .action(async (projectArg, opts) => {
+        const writer = getWriter();
+        const client = requireClient();
+        const format = opts.format;
+        if (!['csv', 'md', 'json'].includes(format)) {
+            throw errUsage('Format must be csv, md, or json', 'Example: feedbackbasket feedback export --format json');
+        }
+        let projectId;
+        if (projectArg) {
+            const project = await resolveProject(client, projectArg);
+            projectId = project.id;
+        }
+        else {
+            const config = loadConfig();
+            if (!config.defaultProject) {
+                throw errUsage('Project is required for export.', 'feedbackbasket feedback export <project> or set a default project');
+            }
+            projectId = config.defaultProject;
+        }
+        const data = await client.exportFeedback(projectId, format);
+        // Export outputs raw data directly — not wrapped in envelope
+        console.log(data);
+    });
+}
+function requireClient() {
+    const manager = new AuthManager();
+    const token = manager.resolveToken();
+    if (!token)
+        throw errAuth();
+    const config = loadConfig();
+    return new FeedbackBasketClient(token, config.baseUrl);
+}

package/dist/src/commands/feedback-note.d.ts

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

package/dist/src/commands/feedback-note.js

@@ -0,0 +1,41 @@
+import { Command } from 'commander';
+import { FeedbackBasketClient } from '../client.js';
+import { AuthManager } from '../auth/manager.js';
+import { loadConfig } from '../config/config.js';
+import { errAuth, errUsage } from '../output/errors.js';
+import { brand } from '../output/theme.js';
+export function createFeedbackNoteCommand(getWriter) {
+    return new Command('note')
+        .argument('<id>', 'Feedback ID to add a note to')
+        .argument('[content]', 'Note content (or use --content)')
+        .description('Add an internal note to a feedback item')
+        .option('--content <text>', 'Note content (alternative to positional argument)')
+        .action(async (id, contentArg, opts) => {
+        const writer = getWriter();
+        const content = contentArg ?? opts.content;
+        if (!content) {
+            throw errUsage('Note content is required', 'Example: feedbackbasket feedback note <id> "Your note here"');
+        }
+        const client = requireClient();
+        const note = await client.createNote(id, content);
+        if (!writer.isMachineOutput()) {
+            console.log(brand.success(`Note added to feedback ${id}`));
+            console.log(`  ${content}`);
+        }
+        writer.ok(note, {
+            summary: `Note added to feedback ${id}`,
+            breadcrumbs: [
+                { action: 'View feedback', cmd: `feedbackbasket feedback show ${id}` },
+                { action: 'Back to list', cmd: 'feedbackbasket feedback list' },
+            ],
+        });
+    });
+}
+function requireClient() {
+    const manager = new AuthManager();
+    const token = manager.resolveToken();
+    if (!token)
+        throw errAuth();
+    const config = loadConfig();
+    return new FeedbackBasketClient(token, config.baseUrl);
+}

package/dist/src/commands/feedback-update.d.ts

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

package/dist/src/commands/feedback-update.js

@@ -0,0 +1,54 @@
+import { Command } from 'commander';
+import { FeedbackBasketClient } from '../client.js';
+import { AuthManager } from '../auth/manager.js';
+import { loadConfig } from '../config/config.js';
+import { errAuth, errUsage } from '../output/errors.js';
+import { brand } from '../output/theme.js';
+export function createFeedbackUpdateCommand(getWriter) {
+    return new Command('update')
+        .argument('<id>', 'Feedback ID to update')
+        .description('Update a feedback item')
+        .option('--status <status>', 'Set status (OPEN, UNDER_REVIEW, PLANNED, IN_PROGRESS, COMPLETE, CLOSED)')
+        .option('--category <category>', 'Set category (BUG, FEATURE_REQUEST, IMPROVEMENT, QUESTION)')
+        .option('--sentiment <sentiment>', 'Set sentiment (POSITIVE, NEGATIVE, NEUTRAL)')
+        .action(async (id, opts) => {
+        const writer = getWriter();
+        if (!opts.status && !opts.category && !opts.sentiment) {
+            throw errUsage('At least one of --status, --category, or --sentiment is required', 'Example: feedbackbasket feedback update <id> --status PLANNED');
+        }
+        const client = requireClient();
+        const data = {};
+        if (opts.status)
+            data['status'] = opts.status;
+        if (opts.category)
+            data['category'] = opts.category;
+        if (opts.sentiment)
+            data['sentiment'] = opts.sentiment;
+        const updated = await client.updateFeedback(id, data);
+        if (!writer.isMachineOutput()) {
+            console.log(brand.success(`Updated feedback ${id}`));
+            if (opts.status)
+                console.log(`  Status:    ${opts.status}`);
+            if (opts.category)
+                console.log(`  Category:  ${opts.category}`);
+            if (opts.sentiment)
+                console.log(`  Sentiment: ${opts.sentiment}`);
+        }
+        writer.ok(updated, {
+            summary: `Updated feedback ${id}`,
+            breadcrumbs: [
+                { action: 'View updated item', cmd: `feedbackbasket feedback show ${id}` },
+                { action: 'Add a note', cmd: `feedbackbasket feedback note ${id} "<note>"` },
+                { action: 'Back to list', cmd: 'feedbackbasket feedback list' },
+            ],
+        });
+    });
+}
+function requireClient() {
+    const manager = new AuthManager();
+    const token = manager.resolveToken();
+    if (!token)
+        throw errAuth();
+    const config = loadConfig();
+    return new FeedbackBasketClient(token, config.baseUrl);
+}

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

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

package/dist/src/commands/feedback.js

@@ -0,0 +1,201 @@
+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 } from '../output/theme.js';
+function resolveProjectId(optProject) {
+    if (optProject)
+        return optProject;
+    const config = loadConfig();
+    return config.defaultProject;
+}
+import { createFeedbackUpdateCommand } from './feedback-update.js';
+import { createFeedbackNoteCommand } from './feedback-note.js';
+import { createFeedbackDeleteCommand } from './feedback-delete.js';
+import { createFeedbackBulkUpdateCommand } from './feedback-bulk-update.js';
+import { createFeedbackExportCommand } from './feedback-export.js';
+export function createFeedbackCommand(getWriter) {
+    const feedback = new Command('feedback')
+        .description('View and manage feedback');
+    // Write subcommands
+    feedback.addCommand(createFeedbackUpdateCommand(getWriter));
+    feedback.addCommand(createFeedbackNoteCommand(getWriter));
+    feedback.addCommand(createFeedbackDeleteCommand(getWriter));
+    feedback.addCommand(createFeedbackBulkUpdateCommand(getWriter));
+    feedback.addCommand(createFeedbackExportCommand(getWriter));
+    // --- feedback list ---
+    feedback
+        .command('list')
+        .description('List feedback with optional filters')
+        .option('--project <id>', 'Filter by project ID')
+        .option('--category <category>', 'Filter by category (BUG, FEATURE_REQUEST, IMPROVEMENT, QUESTION)')
+        .option('--status <status>', 'Filter by status (OPEN, UNDER_REVIEW, PLANNED, IN_PROGRESS, COMPLETE, CLOSED)')
+        .option('--sentiment <sentiment>', 'Filter by sentiment (POSITIVE, NEGATIVE, NEUTRAL)')
+        .option('--search <query>', 'Search feedback 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.getFeedback({
+            projectId: resolveProjectId(opts.project),
+            category: opts.category,
+            status: opts.status,
+            sentiment: opts.sentiment,
+            search: opts.search,
+            limit: parseInt(opts.limit, 10),
+            offset: parseInt(opts.offset, 10),
+            includeNotes: opts.notes ?? false,
+        });
+        if (!writer.isMachineOutput()) {
+            renderFeedbackList(result.feedback);
+        }
+        const breadcrumbs = [];
+        if (opts.project) {
+            breadcrumbs.push({ action: 'View bugs for this project', cmd: `feedbackbasket bugs list --project ${opts.project}` });
+        }
+        if (result.pagination.hasMore) {
+            const nextOffset = parseInt(opts.offset, 10) + parseInt(opts.limit, 10);
+            breadcrumbs.push({ action: 'Next page', cmd: `feedbackbasket feedback list --offset ${nextOffset} --limit ${opts.limit}${opts.project ? ` --project ${opts.project}` : ''}` });
+        }
+        breadcrumbs.push({ action: 'Search', cmd: 'feedbackbasket feedback search "<query>"' });
+        writer.ok(result.feedback, {
+            summary: `Showing ${result.feedback.length} of ${result.pagination.totalCount} feedback items`,
+            notice: result.pagination.hasMore ? `Use --offset ${parseInt(opts.offset, 10) + parseInt(opts.limit, 10)} to see more` : undefined,
+            breadcrumbs,
+        });
+    });
+    // --- feedback show ---
+    feedback
+        .command('show <id>')
+        .description('Show a single feedback item in detail')
+        .action(async (id) => {
+        const writer = getWriter();
+        const client = requireClient();
+        const item = await client.getFeedbackById(id);
+        if (!writer.isMachineOutput()) {
+            renderFeedbackDetail(item);
+        }
+        writer.ok(item, {
+            summary: `Feedback ${item.id}`,
+            breadcrumbs: [
+                { action: 'Update status', cmd: `feedbackbasket feedback update ${item.id} --status <STATUS>` },
+                { action: 'Add note', cmd: `feedbackbasket feedback note ${item.id} "<note>"` },
+                { action: 'Back to list', cmd: 'feedbackbasket feedback list' },
+            ],
+        });
+    });
+    // --- feedback search ---
+    feedback
+        .command('search <query>')
+        .description('Search feedback content across projects')
+        .option('--project <id>', 'Limit to a specific project')
+        .option('--category <category>', 'Filter by category')
+        .option('--limit <n>', 'Max results (1-50)', '10')
+        .action(async (query, opts) => {
+        const writer = getWriter();
+        const client = requireClient();
+        const result = await client.searchFeedback(query, {
+            projectId: resolveProjectId(opts.project),
+            category: opts.category,
+            limit: parseInt(opts.limit, 10),
+        });
+        if (!writer.isMachineOutput()) {
+            renderFeedbackList(result.feedback);
+        }
+        writer.ok(result.feedback, {
+            summary: `${result.pagination.totalCount} result${result.pagination.totalCount === 1 ? '' : 's'} for "${query}"`,
+            breadcrumbs: [
+                { action: 'List all feedback', cmd: 'feedbackbasket feedback list' },
+                { action: 'Search bugs', cmd: `feedbackbasket bugs list --search "${query}"` },
+            ],
+        });
+    });
+    return feedback;
+}
+function requireClient() {
+    const manager = new AuthManager();
+    const token = manager.resolveToken();
+    if (!token)
+        throw errAuth();
+    const config = loadConfig();
+    return new FeedbackBasketClient(token, config.baseUrl);
+}
+const categoryEmoji = {
+    BUG: brand.bug('[BUG]'),
+    FEATURE_REQUEST: brand.feature('[FEATURE]'),
+    IMPROVEMENT: brand.improvement('[IMPROVE]'),
+    QUESTION: brand.question('[QUESTION]'),
+};
+const priorityLabel = (score) => {
+    if (score == null)
+        return brand.muted('--');
+    if (score >= 70)
+        return brand.high(`P${score}`);
+    if (score >= 40)
+        return brand.medium(`P${score}`);
+    return brand.low(`P${score}`);
+};
+function renderFeedbackList(items) {
+    if (items.length === 0)
+        return;
+    for (const item of items) {
+        const cat = categoryEmoji[item.category ?? ''] ?? brand.muted('[?]');
+        const priority = priorityLabel(item.aiPriorityScore);
+        const content = item.content.length > 80 ? item.content.slice(0, 77) + '...' : item.content;
+        const status = brand.muted(`[${item.status}]`);
+        console.log(`${cat} ${priority} ${status} ${brand.muted(item.id)}`);
+        console.log(`  ${content}`);
+        if (item.aiSummary) {
+            console.log(`  ${brand.hint(item.aiSummary)}`);
+        }
+        console.log();
+    }
+}
+function renderFeedbackDetail(item) {
+    console.log(brand.bold(`Feedback ${item.id}`));
+    console.log(brand.divider('─'.repeat(50)));
+    console.log();
+    const fields = [
+        ['Status', item.status],
+        ['Category', item.category],
+        ['Sentiment', item.sentiment],
+        ['Priority', item.aiPriorityScore != null ? String(item.aiPriorityScore) : null],
+        ['Email', item.email],
+        ['Project', `${item.project.name} (${item.project.id})`],
+        ['Page URL', item.pageUrl],
+        ['Browser', item.browser],
+        ['OS', item.os],
+        ['Device', item.device],
+        ['Language', item.language],
+        ['Created', item.createdAt],
+    ];
+    for (const [label, value] of fields) {
+        if (value) {
+            console.log(`  ${brand.bold(label.padEnd(12))} ${value}`);
+        }
+    }
+    console.log();
+    console.log(brand.bold('Content:'));
+    console.log(`  ${item.content}`);
+    if (item.aiSummary) {
+        console.log();
+        console.log(brand.bold('AI Summary:'));
+        console.log(`  ${brand.hint(item.aiSummary)}`);
+    }
+    if (item.reasoning) {
+        console.log();
+        console.log(brand.bold('AI Reasoning:'));
+        console.log(`  ${brand.hint(item.reasoning)}`);
+    }
+    if (item.notes && item.notes.length > 0) {
+        console.log();
+        console.log(brand.bold(`Notes (${item.notes.length}):`));
+        for (const note of item.notes) {
+            console.log(`  ${brand.muted(note.createdAt)} ${brand.primary(note.author.name)}`);
+            console.log(`    ${note.content}`);
+        }
+    }
+}

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

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