feedbackbasket-cli 0.3.0

package/dist/src/config/credentials.js

@@ -0,0 +1,39 @@
+import { readFileSync, writeFileSync, unlinkSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { configDir, ensureConfigDir } from './config.js';
+function credentialsPath() {
+    return join(configDir(), 'credentials.json');
+}
+export function loadCredentials() {
+    // Environment variable takes precedence (like Basecamp's BASECAMP_TOKEN)
+    const envToken = process.env['FEEDBACKBASKET_TOKEN'];
+    if (envToken) {
+        return {
+            token: envToken,
+            scope: 'full',
+            createdAt: new Date().toISOString(),
+        };
+    }
+    try {
+        const raw = readFileSync(credentialsPath(), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveCredentials(creds) {
+    ensureConfigDir();
+    writeFileSync(credentialsPath(), JSON.stringify(creds, null, 2) + '\n', { mode: 0o600 });
+}
+export function clearCredentials() {
+    const path = credentialsPath();
+    if (existsSync(path)) {
+        unlinkSync(path);
+    }
+}
+export function maskToken(token) {
+    if (token.length <= 20)
+        return token.slice(0, 8) + '...';
+    return token.slice(0, 14) + '...' + token.slice(-4);
+}

package/dist/src/output/codes.d.ts

@@ -0,0 +1,16 @@
+export declare const ExitOK = 0;
+export declare const ExitUsage = 1;
+export declare const ExitNotFound = 2;
+export declare const ExitAuth = 3;
+export declare const ExitForbidden = 4;
+export declare const ExitRateLimit = 5;
+export declare const ExitNetwork = 6;
+export declare const ExitAPI = 7;
+export declare const CodeUsage = "usage_error";
+export declare const CodeNotFound = "not_found";
+export declare const CodeAuth = "auth_error";
+export declare const CodeForbidden = "forbidden";
+export declare const CodeRateLimit = "rate_limit";
+export declare const CodeNetwork = "network_error";
+export declare const CodeAPI = "api_error";
+export declare function exitCodeFor(code: string): number;

package/dist/src/output/codes.js

@@ -0,0 +1,29 @@
+// Exit codes — matching Basecamp CLI conventions
+export const ExitOK = 0;
+export const ExitUsage = 1;
+export const ExitNotFound = 2;
+export const ExitAuth = 3;
+export const ExitForbidden = 4;
+export const ExitRateLimit = 5;
+export const ExitNetwork = 6;
+export const ExitAPI = 7;
+// Error codes (string identifiers for JSON envelope)
+export const CodeUsage = 'usage_error';
+export const CodeNotFound = 'not_found';
+export const CodeAuth = 'auth_error';
+export const CodeForbidden = 'forbidden';
+export const CodeRateLimit = 'rate_limit';
+export const CodeNetwork = 'network_error';
+export const CodeAPI = 'api_error';
+const codeToExit = {
+    [CodeUsage]: ExitUsage,
+    [CodeNotFound]: ExitNotFound,
+    [CodeAuth]: ExitAuth,
+    [CodeForbidden]: ExitForbidden,
+    [CodeRateLimit]: ExitRateLimit,
+    [CodeNetwork]: ExitNetwork,
+    [CodeAPI]: ExitAPI,
+};
+export function exitCodeFor(code) {
+    return codeToExit[code] ?? ExitAPI;
+}

package/dist/src/output/envelope.d.ts

@@ -0,0 +1,24 @@
+export interface Breadcrumb {
+    action: string;
+    cmd: string;
+    description?: string;
+}
+export interface SuccessResponse<T = unknown> {
+    ok: true;
+    data: T;
+    summary?: string;
+    notice?: string;
+    breadcrumbs?: Breadcrumb[];
+}
+export interface ErrorResponse {
+    ok: false;
+    error: string;
+    code: string;
+    hint?: string;
+}
+export type Response<T = unknown> = SuccessResponse<T> | ErrorResponse;
+export interface ResponseOptions {
+    summary?: string;
+    notice?: string;
+    breadcrumbs?: Breadcrumb[];
+}

package/dist/src/output/envelope.js

@@ -0,0 +1,2 @@
+// JSON envelope types — adapted from Basecamp CLI's Response struct
+export {};

package/dist/src/output/errors.d.ts

@@ -0,0 +1,13 @@
+export declare class CLIError extends Error {
+    readonly code: string;
+    readonly hint?: string;
+    readonly exitCode: number;
+    constructor(code: string, message: string, hint?: string);
+}
+export declare function errAuth(message?: string): CLIError;
+export declare function errNotFound(resource: string, id: string): CLIError;
+export declare function errForbidden(message?: string): CLIError;
+export declare function errRateLimit(): CLIError;
+export declare function errNetwork(cause?: Error): CLIError;
+export declare function errAPI(status: number, message: string): CLIError;
+export declare function errUsage(message: string, hint?: string): CLIError;

package/dist/src/output/errors.js

@@ -0,0 +1,37 @@
+import { CodeAuth, CodeNotFound, CodeForbidden, CodeRateLimit, CodeNetwork, CodeAPI, CodeUsage, exitCodeFor, } from './codes.js';
+export class CLIError extends Error {
+    code;
+    hint;
+    exitCode;
+    constructor(code, message, hint) {
+        super(message);
+        this.name = 'CLIError';
+        this.code = code;
+        this.hint = hint;
+        this.exitCode = exitCodeFor(code);
+    }
+}
+export function errAuth(message = 'Not authenticated') {
+    return new CLIError(CodeAuth, message, 'Run: feedbackbasket auth login');
+}
+export function errNotFound(resource, id) {
+    return new CLIError(CodeNotFound, `${resource} "${id}" not found`);
+}
+export function errForbidden(message = 'Access denied') {
+    return new CLIError(CodeForbidden, message, 'This action requires --scope full');
+}
+export function errRateLimit() {
+    return new CLIError(CodeRateLimit, 'Rate limit exceeded', 'Wait a moment and try again');
+}
+export function errNetwork(cause) {
+    const message = cause?.message
+        ? `Network error: ${cause.message}`
+        : 'Could not connect to FeedbackBasket';
+    return new CLIError(CodeNetwork, message, 'Check your internet connection and try again');
+}
+export function errAPI(status, message) {
+    return new CLIError(CodeAPI, `API error (${status}): ${message}`);
+}
+export function errUsage(message, hint) {
+    return new CLIError(CodeUsage, message, hint);
+}

package/dist/src/output/styled.d.ts

@@ -0,0 +1,4 @@
+import type { ResponseOptions } from './envelope.js';
+import type { CLIError } from './errors.js';
+export declare function renderStyledResponse(data: unknown, opts: ResponseOptions): void;
+export declare function renderStyledError(error: CLIError): void;

package/dist/src/output/styled.js

@@ -0,0 +1,78 @@
+import { brand, divider } from './theme.js';
+export function renderStyledResponse(data, opts) {
+    if (opts.summary) {
+        console.log(brand.primaryBold(opts.summary));
+        console.log();
+    }
+    if (Array.isArray(data)) {
+        renderArray(data);
+    }
+    else if (data && typeof data === 'object') {
+        renderObject(data);
+    }
+    else {
+        console.log(String(data));
+    }
+    if (opts.notice) {
+        console.log();
+        console.log(brand.warning(opts.notice));
+    }
+    if (opts.breadcrumbs && opts.breadcrumbs.length > 0) {
+        renderBreadcrumbs(opts.breadcrumbs);
+    }
+}
+export function renderStyledError(error) {
+    console.error(brand.error.bold(`Error: ${error.message}`));
+    if (error.hint) {
+        console.error(brand.muted(`  Hint: ${error.hint}`));
+    }
+}
+function renderBreadcrumbs(breadcrumbs) {
+    console.log();
+    console.log(divider());
+    console.log(brand.bold('Hints:'));
+    for (const bc of breadcrumbs) {
+        const desc = bc.description ? brand.muted(` — ${bc.description}`) : '';
+        console.log(`  ${brand.command(bc.cmd)}${desc}`);
+    }
+}
+function renderArray(items) {
+    if (items.length === 0) {
+        console.log(brand.muted('  No results'));
+        return;
+    }
+    for (const item of items) {
+        if (item && typeof item === 'object') {
+            renderObject(item);
+            console.log();
+        }
+        else {
+            console.log(`  ${String(item)}`);
+        }
+    }
+}
+function renderObject(obj) {
+    const maxKeyLen = Math.max(...Object.keys(obj).map(k => k.length));
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === null || value === undefined)
+            continue;
+        const label = brand.label(key.padEnd(maxKeyLen));
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                console.log(`  ${label}  ${brand.muted('(none)')}`);
+            }
+            else if (typeof value[0] === 'object') {
+                console.log(`  ${label}  ${brand.muted(`(${value.length} items)`)}`);
+            }
+            else {
+                console.log(`  ${label}  ${value.join(', ')}`);
+            }
+        }
+        else if (typeof value === 'object') {
+            console.log(`  ${label}  ${JSON.stringify(value)}`);
+        }
+        else {
+            console.log(`  ${label}  ${String(value)}`);
+        }
+    }
+}

package/dist/src/output/theme.d.ts

@@ -0,0 +1,25 @@
+export declare const brand: {
+    primary: import("chalk").ChalkInstance;
+    primaryBold: import("chalk").ChalkInstance;
+    bold: import("chalk").ChalkInstance;
+    muted: import("chalk").ChalkInstance;
+    dim: import("chalk").ChalkInstance;
+    success: import("chalk").ChalkInstance;
+    error: import("chalk").ChalkInstance;
+    warning: import("chalk").ChalkInstance;
+    info: import("chalk").ChalkInstance;
+    label: import("chalk").ChalkInstance;
+    value: import("chalk").ChalkInstance;
+    hint: import("chalk").ChalkInstance;
+    divider: import("chalk").ChalkInstance;
+    command: import("chalk").ChalkInstance;
+    bug: import("chalk").ChalkInstance;
+    feature: import("chalk").ChalkInstance;
+    improvement: import("chalk").ChalkInstance;
+    question: import("chalk").ChalkInstance;
+    high: import("chalk").ChalkInstance;
+    medium: import("chalk").ChalkInstance;
+    low: import("chalk").ChalkInstance;
+};
+export declare function divider(width?: number): string;
+export declare function logo(): string;

package/dist/src/output/theme.js

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+// FeedbackBasket brand colors
+// Primary: green (#22c55e) — used for accents, commands, success
+// Foreground: white/gray — standard text
+// Error: red — errors, bugs, high severity
+// Warning: amber/yellow — notices, medium severity
+// Muted: gray — secondary text, dividers
+export const brand = {
+    // Primary accent — use instead of cyan
+    primary: chalk.hex('#22c55e'),
+    primaryBold: chalk.hex('#22c55e').bold,
+    // Text
+    bold: chalk.bold,
+    muted: chalk.gray,
+    dim: chalk.dim,
+    // Status
+    success: chalk.hex('#22c55e'),
+    error: chalk.red,
+    warning: chalk.yellow,
+    info: chalk.blue,
+    // Semantic
+    label: chalk.bold,
+    value: chalk.white,
+    hint: chalk.gray.italic,
+    divider: chalk.gray,
+    command: chalk.hex('#22c55e'),
+    // Category badges
+    bug: chalk.red,
+    feature: chalk.hex('#22c55e'),
+    improvement: chalk.hex('#06b6d4'),
+    question: chalk.yellow,
+    // Severity
+    high: chalk.red,
+    medium: chalk.yellow,
+    low: chalk.hex('#22c55e'),
+};
+// Box drawing
+export function divider(width = 50) {
+    return brand.muted('─'.repeat(width));
+}
+export function logo() {
+    return `${brand.primaryBold('Feedback')}${brand.bold('Basket')}`;
+}

package/dist/src/output/writer.d.ts

@@ -0,0 +1,23 @@
+import type { ResponseOptions } from './envelope.js';
+import { CLIError } from './errors.js';
+export declare enum Format {
+    Auto = "auto",
+    JSON = "json",
+    Quiet = "quiet",
+    Styled = "styled",
+    Markdown = "markdown"
+}
+export interface WriterOptions {
+    format: Format;
+}
+export declare class OutputWriter {
+    private format;
+    constructor(opts: WriterOptions);
+    effectiveFormat(): Format;
+    isMachineOutput(): boolean;
+    ok<T>(data: T, opts?: ResponseOptions): void;
+    err(error: CLIError): void;
+    private renderJSON;
+    private renderQuiet;
+    private renderMarkdown;
+}

package/dist/src/output/writer.js

@@ -0,0 +1,109 @@
+import { renderStyledResponse, renderStyledError } from './styled.js';
+export var Format;
+(function (Format) {
+    Format["Auto"] = "auto";
+    Format["JSON"] = "json";
+    Format["Quiet"] = "quiet";
+    Format["Styled"] = "styled";
+    Format["Markdown"] = "markdown";
+})(Format || (Format = {}));
+export class OutputWriter {
+    format;
+    constructor(opts) {
+        this.format = opts.format;
+    }
+    effectiveFormat() {
+        if (this.format !== Format.Auto)
+            return this.format;
+        return process.stdout.isTTY ? Format.Styled : Format.JSON;
+    }
+    isMachineOutput() {
+        const f = this.effectiveFormat();
+        return f === Format.JSON || f === Format.Quiet;
+    }
+    ok(data, opts = {}) {
+        const format = this.effectiveFormat();
+        switch (format) {
+            case Format.JSON:
+                this.renderJSON(data, opts);
+                break;
+            case Format.Quiet:
+                this.renderQuiet(data);
+                break;
+            case Format.Markdown:
+                this.renderMarkdown(data, opts);
+                break;
+            case Format.Styled:
+            default:
+                renderStyledResponse(data, opts);
+                break;
+        }
+    }
+    err(error) {
+        const format = this.effectiveFormat();
+        if (format === Format.JSON || format === Format.Quiet) {
+            const envelope = {
+                ok: false,
+                error: error.message,
+                code: error.code,
+                hint: error.hint,
+            };
+            console.error(JSON.stringify(envelope));
+        }
+        else {
+            renderStyledError(error);
+        }
+    }
+    renderJSON(data, opts) {
+        const envelope = {
+            ok: true,
+            data,
+            summary: opts.summary,
+            notice: opts.notice,
+            breadcrumbs: opts.breadcrumbs,
+        };
+        console.log(JSON.stringify(envelope, null, 2));
+    }
+    renderQuiet(data) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    renderMarkdown(data, opts) {
+        if (opts.summary) {
+            console.log(`## ${opts.summary}\n`);
+        }
+        if (Array.isArray(data)) {
+            for (const item of data) {
+                if (item && typeof item === 'object') {
+                    for (const [key, value] of Object.entries(item)) {
+                        if (value !== null && value !== undefined) {
+                            console.log(`- **${key}**: ${String(value)}`);
+                        }
+                    }
+                    console.log();
+                }
+                else {
+                    console.log(`- ${String(item)}`);
+                }
+            }
+        }
+        else if (data && typeof data === 'object') {
+            for (const [key, value] of Object.entries(data)) {
+                if (value !== null && value !== undefined) {
+                    console.log(`- **${key}**: ${String(value)}`);
+                }
+            }
+        }
+        else {
+            console.log(String(data));
+        }
+        if (opts.notice) {
+            console.log(`\n> ${opts.notice}`);
+        }
+        if (opts.breadcrumbs && opts.breadcrumbs.length > 0) {
+            console.log('\n### Hints\n');
+            for (const bc of opts.breadcrumbs) {
+                console.log(`- \`${bc.cmd}\` — ${bc.action}`);
+            }
+        }
+    }
+}

package/dist/src/prompt.d.ts

@@ -0,0 +1,3 @@
+export declare function ask(question: string): Promise<string>;
+export declare function confirm(question: string, defaultYes?: boolean): Promise<boolean>;
+export declare function select(question: string, options: string[]): Promise<number | null>;

package/dist/src/prompt.js

@@ -0,0 +1,32 @@
+import { createInterface } from 'node:readline';
+const rl = () => createInterface({ input: process.stdin, output: process.stdout });
+export function ask(question) {
+    return new Promise((resolve) => {
+        const iface = rl();
+        iface.question(question, (answer) => {
+            iface.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function confirm(question, defaultYes = true) {
+    const hint = defaultYes ? 'Y/n' : 'y/N';
+    const answer = await ask(`${question} (${hint}): `);
+    if (answer === '')
+        return defaultYes;
+    return answer.toLowerCase().startsWith('y');
+}
+export async function select(question, options) {
+    for (let i = 0; i < options.length; i++) {
+        console.log(`    ${i + 1}. ${options[i]}`);
+    }
+    console.log();
+    const answer = await ask(`  ${question} (1-${options.length}, or skip): `);
+    if (answer === '' || answer.toLowerCase() === 'skip' || answer.toLowerCase() === 's') {
+        return null;
+    }
+    const num = parseInt(answer, 10);
+    if (isNaN(num) || num < 1 || num > options.length)
+        return null;
+    return num - 1;
+}

package/dist/src/resolve.d.ts

@@ -0,0 +1,9 @@
+import { FeedbackBasketClient } from './client.js';
+import type { Project } from './types.js';
+/**
+ * Resolve a project by ID or name.
+ * - If input looks like a cuid, treat as ID
+ * - Otherwise, fetch all projects and match by name (case-insensitive)
+ * - Supports partial matching (e.g. "feedback" matches "feedbackbasket")
+ */
+export declare function resolveProject(client: FeedbackBasketClient, input: string): Promise<Project>;

package/dist/src/resolve.js

@@ -0,0 +1,70 @@
+import { errNotFound, errUsage } from './output/errors.js';
+// CUIDs look like: cmn3c7sgv000004jx16lhl07o (25 chars, starts with c, alphanumeric)
+function looksLikeId(input) {
+    return /^c[a-z0-9]{20,}$/.test(input);
+}
+/**
+ * Resolve a project by ID or name.
+ * - If input looks like a cuid, treat as ID
+ * - Otherwise, fetch all projects and match by name (case-insensitive)
+ * - Supports partial matching (e.g. "feedback" matches "feedbackbasket")
+ */
+export async function resolveProject(client, input) {
+    // Direct ID lookup
+    if (looksLikeId(input)) {
+        return client.getProject(input);
+    }
+    // Name-based lookup — fetch all projects and match
+    const result = await client.listProjects();
+    const projects = result.projects;
+    if (projects.length === 0) {
+        throw errNotFound('project', input);
+    }
+    const lower = input.toLowerCase();
+    // 1. Exact match (case-insensitive)
+    const exact = projects.filter(p => p.name.toLowerCase() === lower);
+    if (exact.length === 1)
+        return exact[0];
+    // 2. Starts-with match
+    const startsWith = projects.filter(p => p.name.toLowerCase().startsWith(lower));
+    if (startsWith.length === 1)
+        return startsWith[0];
+    // 3. Contains match
+    const contains = projects.filter(p => p.name.toLowerCase().includes(lower));
+    if (contains.length === 1)
+        return contains[0];
+    // Ambiguous — multiple matches
+    if (contains.length > 1) {
+        const names = contains.map(p => `  - ${p.name} (${p.id})`).join('\n');
+        throw errUsage(`Ambiguous project name "${input}" — matches ${contains.length} projects:\n${names}`, `Use the full project ID or a more specific name`);
+    }
+    // Not found — suggest similar names
+    const suggestions = projects
+        .map(p => ({ name: p.name, dist: levenshtein(lower, p.name.toLowerCase()) }))
+        .sort((a, b) => a.dist - b.dist)
+        .slice(0, 3)
+        .filter(s => s.dist <= Math.max(input.length * 0.6, 3))
+        .map(s => s.name);
+    if (suggestions.length > 0) {
+        throw errUsage(`Project "${input}" not found. Did you mean: ${suggestions.join(', ')}?`, `Use feedbackbasket projects list to see all projects`);
+    }
+    throw errNotFound('project', input);
+}
+// Simple Levenshtein distance for typo suggestions
+function levenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1]
+                ? dp[i - 1][j - 1]
+                : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}

package/dist/src/types.d.ts

@@ -0,0 +1,100 @@
+export type FeedbackStatus = 'OPEN' | 'UNDER_REVIEW' | 'PLANNED' | 'IN_PROGRESS' | 'COMPLETE' | 'CLOSED';
+export type FeedbackCategory = 'BUG' | 'FEATURE_REQUEST' | 'IMPROVEMENT' | 'QUESTION';
+export type Sentiment = 'POSITIVE' | 'NEGATIVE' | 'NEUTRAL';
+export type Severity = 'high' | 'medium' | 'low';
+export interface Project {
+    id: string;
+    name: string;
+    url: string;
+    description?: string;
+    createdAt: string;
+    totalFeedback: number;
+    byStatus: Record<string, number>;
+    byCategory: Record<string, number>;
+}
+export interface Feedback {
+    id: string;
+    content: string;
+    email?: string | null;
+    status: FeedbackStatus;
+    category?: FeedbackCategory | null;
+    sentiment?: Sentiment | null;
+    aiSummary?: string | null;
+    aiPriorityScore?: number | null;
+    reasoning?: string | null;
+    pageUrl?: string | null;
+    browser?: string | null;
+    os?: string | null;
+    device?: string | null;
+    language?: string | null;
+    project: {
+        id: string;
+        name: string;
+    };
+    notes?: FeedbackNote[];
+    createdAt: string;
+}
+export interface FeedbackNote {
+    id: string;
+    content: string;
+    createdAt: string;
+    author: {
+        name: string;
+    };
+}
+export interface BugReport extends Feedback {
+    severity: Severity;
+}
+export interface ProjectsResponse {
+    projects: Project[];
+    totalProjects: number;
+}
+export interface Pagination {
+    totalCount: number;
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+}
+export interface FeedbackResponse {
+    feedback: Feedback[];
+    pagination: Pagination;
+}
+export interface BugReportsResponse {
+    bugReports: BugReport[];
+    stats: {
+        total: number;
+        bySeverity: {
+            high: number;
+            medium: number;
+            low: number;
+        };
+        byStatus: Record<string, number>;
+    };
+    pagination: Pagination;
+}
+export interface FeedbackParams {
+    projectId?: string;
+    category?: FeedbackCategory;
+    status?: FeedbackStatus;
+    sentiment?: Sentiment;
+    search?: string;
+    limit?: number;
+    offset?: number;
+    includeNotes?: boolean;
+}
+export interface BugReportParams {
+    projectId?: string;
+    status?: FeedbackStatus;
+    severity?: Severity;
+    search?: string;
+    limit?: number;
+    offset?: number;
+    includeNotes?: boolean;
+}
+export interface UserProfile {
+    id: string;
+    name: string;
+    email: string;
+    organizationId: string;
+    organizationName: string;
+}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+// API response types — aligned with FeedbackBasket v3 REST API
+export {};

package/dist/src/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "0.3.0";
+export declare const USER_AGENT = "FeedbackBasket-CLI/0.3.0";