@embeddables/cli 0.8.0 → 0.8.1

package/dist/commands/experiments-connect.js

@@ -0,0 +1,140 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { isLoggedIn } from '../auth/index.js';
+import { getProjectId, writeProjectConfig } from '../config/index.js';
+import { promptForProject, promptForLocalEmbeddable, promptForExperiment, } from '../prompts/index.js';
+import { createLogger, exit } from '../logger.js';
+import { getSentryContextFromEmbeddableConfig, getSentryContextFromProjectConfig, setSentryContext, } from '../sentry-context.js';
+import * as stdout from '../stdout.js';
+import { inferEmbeddableFromCwd } from '../helpers/utils.js';
+export async function runExperimentsConnect(opts) {
+    const logger = createLogger('runExperimentsConnect');
+    try {
+        await runExperimentsConnectInner(opts);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            stdout.error(`Connect failed: ${error.message}`);
+        }
+        else {
+            stdout.error('Connect failed with an unexpected error.');
+        }
+        logger.error('experiments connect failed', {
+            message: error instanceof Error ? error.message : 'unexpected error',
+        });
+        await exit(1);
+    }
+}
+async function runExperimentsConnectInner(opts) {
+    const logger = createLogger('runExperimentsConnect');
+    // 1. Check login (needed for fetching experiments from Supabase)
+    if (!isLoggedIn()) {
+        stdout.warn('Not logged in.');
+        stdout.dim('Run "embeddables login" first.');
+        logger.error('not logged in');
+        await exit(1);
+    }
+    // 2. Get project ID (needed for experiment list)
+    let projectId = getProjectId();
+    if (!projectId) {
+        stdout.step('No project configured. Fetching projects…');
+        const selectedProject = await promptForProject();
+        if (!selectedProject) {
+            await exit(1);
+            return;
+        }
+        projectId = selectedProject.id;
+        writeProjectConfig({
+            org_id: selectedProject.org_id || undefined,
+            org_title: selectedProject.org_title || undefined,
+            project_id: projectId,
+            project_name: selectedProject.title || undefined,
+        });
+        stdout.success('Saved project to embeddables.json');
+        stdout.gap();
+    }
+    // 4. Get embeddable ID (from option, cwd inference, or interactive prompt)
+    const inferred = inferEmbeddableFromCwd();
+    let embeddableId = opts.id ?? inferred?.embeddableId;
+    if (inferred && !opts.id && embeddableId) {
+        process.chdir(inferred.projectRoot);
+    }
+    setSentryContext(getSentryContextFromProjectConfig());
+    if (!embeddableId) {
+        const selected = await promptForLocalEmbeddable({
+            message: 'Select an embeddable to connect the experiment to:',
+        });
+        if (!selected) {
+            await exit(1);
+            return;
+        }
+        embeddableId = selected;
+        stdout.gap();
+    }
+    if (embeddableId) {
+        setSentryContext({
+            embeddable: { id: embeddableId },
+            ...getSentryContextFromEmbeddableConfig(embeddableId),
+        });
+    }
+    // 5. Get experiment_id and experiment_key (from opts or interactive prompt)
+    let experimentId = opts.experimentId;
+    let experimentKey = opts.experimentKey;
+    if (experimentId && !experimentKey) {
+        stdout.error('When using --experiment-id, --experiment-key is also required.');
+        logger.error('missing experiment-key flag');
+        await exit(1);
+    }
+    if (experimentKey && !experimentId) {
+        stdout.error('When using --experiment-key, --experiment-id is also required.');
+        logger.error('missing experiment-id flag');
+        await exit(1);
+    }
+    if (!experimentId || !experimentKey) {
+        const selected = await stdout.withSpinner('Fetching experiments…', async () => {
+            return promptForExperiment(projectId, {
+                message: 'Select an experiment to connect:',
+                excludeConnectedTo: embeddableId,
+            });
+        }, { successText: 'Experiments loaded' });
+        if (!selected) {
+            await exit(1);
+            return;
+        }
+        experimentId = selected.experiment_id;
+        experimentKey = selected.experiment_key;
+        stdout.gap();
+    }
+    // 6. Read config.json
+    const configPath = path.join('embeddables', embeddableId, 'config.json');
+    if (!fs.existsSync(configPath)) {
+        stdout.error(`No config.json found at ${configPath}`);
+        stdout.dim('Run "embeddables pull" or "embeddables init" first.');
+        logger.error('config not found', { configPath });
+        await exit(1);
+    }
+    let config;
+    try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        config = JSON.parse(content);
+    }
+    catch {
+        stdout.error('Failed to parse config.json.');
+        logger.error('failed to parse config');
+        await exit(1);
+        return;
+    }
+    // 7. Append to connected_experiments
+    const connectedExperiments = Array.isArray(config.connected_experiments) ? [...config.connected_experiments] : [];
+    const alreadyConnected = connectedExperiments.some((e) => e.experiment_id === experimentId && e.experiment_key === experimentKey);
+    if (alreadyConnected) {
+        stdout.warn(`Experiment "${experimentKey}" is already connected to this embeddable.`);
+        return;
+    }
+    connectedExperiments.push({ experiment_id: experimentId, experiment_key: experimentKey });
+    config.connected_experiments = connectedExperiments;
+    // 8. Write the modified config back
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+    stdout.success(`Connected experiment "${experimentKey}" to embeddable`);
+    stdout.dim('Run "embeddables save" to persist to the cloud.');
+}

package/dist/commands/feedback.d.ts

@@ -0,0 +1,29 @@
+export type FeedbackCategory = 'cli' | 'ai' | 'compiler' | 'other';
+export interface RunFeedbackOptions {
+    message?: string;
+    positive?: boolean;
+    negative?: boolean;
+    category?: FeedbackCategory;
+}
+export declare function runFeedback(opts: RunFeedbackOptions): Promise<void>;
+export interface FeedbackContext {
+    userEmail?: string;
+    userName?: string;
+    cliVersion?: string;
+    nodeVersion?: string;
+    platform?: string;
+    osRelease?: string;
+    arch?: string;
+    projectId?: string;
+    projectName?: string;
+    orgId?: string;
+    orgName?: string;
+    embeddableId?: string;
+    lastCommand?: Record<string, unknown>;
+    gitBranch?: string;
+    gitDirty?: boolean;
+    aiTool?: string;
+}
+export declare function collectFeedbackContext(): FeedbackContext;
+export declare function detectAiTool(): string | undefined;
+//# sourceMappingURL=feedback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feedback.d.ts","sourceRoot":"","sources":["../../src/commands/feedback.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,IAAI,GAAG,UAAU,GAAG,OAAO,CAAA;AAElE,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,gBAAgB,CAAA;CAC5B;AAID,wBAAsB,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsIzE;AAID,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACrC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,wBAAgB,sBAAsB,IAAI,eAAe,CA+FxD;AAED,wBAAgB,YAAY,IAAI,MAAM,GAAG,SAAS,CA0BjD"}

package/dist/commands/feedback.js

@@ -0,0 +1,267 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import * as Sentry from '@sentry/node';
+import { createLogger } from '../logger.js';
+import * as stdout from '../stdout.js';
+import { prompt } from '../helpers/prompt.js';
+import { readProjectConfig } from '../config/index.js';
+import { getLastHistoryEntry } from '../command-history.js';
+import { getSentryContextFromEmbeddableConfig, setSentryContext } from '../sentry-context.js';
+const logger = createLogger('runFeedback');
+const VALID_CATEGORIES = new Set(['cli', 'ai', 'compiler', 'other']);
+export async function runFeedback(opts) {
+    // 1. Resolve message
+    let message = opts.message;
+    if (!message) {
+        const res = await prompt({
+            type: 'text',
+            name: 'value',
+            message: "What's your feedback?",
+        });
+        message = res.value?.trim();
+        if (!message) {
+            stdout.warn('No feedback provided.');
+            return;
+        }
+    }
+    // 2. Resolve sentiment
+    let sentiment;
+    if (opts.positive) {
+        sentiment = 'positive';
+    }
+    else if (opts.negative) {
+        sentiment = 'negative';
+    }
+    else if (!opts.message) {
+        const res = await prompt({
+            type: 'select',
+            name: 'value',
+            message: 'Was this positive or negative?',
+            choices: [
+                { title: '👍 Positive', value: 'positive' },
+                { title: '👎 Negative', value: 'negative' },
+            ],
+        });
+        sentiment = res.value === 'positive' ? 'positive' : 'negative';
+    }
+    else {
+        sentiment = 'negative';
+    }
+    // 3. Resolve category
+    let category = opts.category;
+    if (category && !VALID_CATEGORIES.has(category)) {
+        stdout.warn(`Invalid category "${category}". Must be one of: cli, ai, compiler, other`);
+        category = undefined;
+    }
+    if (!category && !opts.message) {
+        const res = await prompt({
+            type: 'select',
+            name: 'value',
+            message: 'Which area does this relate to?',
+            choices: [
+                { title: 'CLI command', value: 'cli' },
+                { title: 'AI prompts', value: 'ai' },
+                { title: 'Compiler', value: 'compiler' },
+                { title: 'Other', value: 'other' },
+            ],
+        });
+        category = res.value || undefined;
+    }
+    // 4. Collect context
+    const context = collectFeedbackContext();
+    // 5. Set Sentry context and send
+    Sentry.setTag('feedback.sentiment', sentiment);
+    if (category)
+        Sentry.setTag('feedback.category', category);
+    Sentry.setContext('feedback', {
+        sentiment,
+        category: category ?? null,
+    });
+    if (context.cliVersion)
+        Sentry.setTag('cli.version', context.cliVersion);
+    if (context.nodeVersion)
+        Sentry.setTag('node.version', context.nodeVersion);
+    if (context.platform)
+        Sentry.setTag('os.platform', context.platform);
+    if (context.arch)
+        Sentry.setTag('os.arch', context.arch);
+    Sentry.setContext('environment', {
+        cliVersion: context.cliVersion ?? null,
+        nodeVersion: context.nodeVersion ?? null,
+        platform: context.platform ?? null,
+        osRelease: context.osRelease ?? null,
+        arch: context.arch ?? null,
+    });
+    if (context.projectId || context.orgId) {
+        setSentryContext({
+            project: context.projectId
+                ? { id: context.projectId, title: context.projectName ?? null }
+                : undefined,
+            org: context.orgId ? { id: context.orgId, title: context.orgName ?? null } : undefined,
+        });
+    }
+    if (context.embeddableId) {
+        const embCtx = getSentryContextFromEmbeddableConfig(context.embeddableId);
+        setSentryContext({
+            embeddable: { id: context.embeddableId },
+            ...embCtx,
+        });
+    }
+    if (context.lastCommand) {
+        Sentry.setContext('lastCommand', context.lastCommand);
+    }
+    Sentry.setContext('git', {
+        branch: context.gitBranch ?? null,
+        dirty: context.gitDirty ?? null,
+    });
+    if (context.aiTool) {
+        Sentry.setTag('ai.tool', context.aiTool);
+        Sentry.setContext('ai', { tool: context.aiTool });
+    }
+    Sentry.captureFeedback({
+        message,
+        email: context.userEmail ?? undefined,
+        name: context.userName ?? undefined,
+    });
+    await Sentry.flush(5000);
+    // 6. Show confirmation
+    stdout.gap();
+    const icon = sentiment === 'positive' ? '👍' : '👎';
+    stdout.success(`Feedback sent ${icon}`);
+    stdout.dim('Thanks for helping us improve!');
+    logger.info('feedback sent', {
+        sentiment,
+        category: category ?? 'none',
+        hasEmail: !!context.userEmail,
+        messageLength: message.length,
+    });
+}
+export function collectFeedbackContext() {
+    const ctx = {};
+    // User email from auth (best effort, no await — read sync from file)
+    try {
+        const authPath = path.join(os.homedir(), '.embeddables', 'auth.json');
+        if (fs.existsSync(authPath)) {
+            const raw = JSON.parse(fs.readFileSync(authPath, 'utf8'));
+            if (raw.access_token && typeof raw.access_token === 'string') {
+                const payload = JSON.parse(Buffer.from(raw.access_token.split('.')[1], 'base64').toString());
+                if (typeof payload.email === 'string')
+                    ctx.userEmail = payload.email;
+                if (typeof payload.name === 'string')
+                    ctx.userName = payload.name;
+            }
+        }
+    }
+    catch {
+        // auth not available — fine
+    }
+    // CLI version
+    try {
+        const pkgPath = path.join(path.dirname(new URL(import.meta.url).pathname), '..', 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        if (typeof pkg.version === 'string')
+            ctx.cliVersion = pkg.version;
+    }
+    catch {
+        // ignore
+    }
+    // Node / OS
+    ctx.nodeVersion = process.version;
+    ctx.platform = process.platform;
+    ctx.osRelease = os.release();
+    ctx.arch = process.arch;
+    // Project config
+    try {
+        const config = readProjectConfig();
+        if (config?.project_id)
+            ctx.projectId = config.project_id;
+        if (config?.project_name)
+            ctx.projectName = config.project_name;
+        if (config?.org_id)
+            ctx.orgId = config.org_id;
+        if (config?.org_title)
+            ctx.orgName = config.org_title;
+    }
+    catch {
+        // ignore
+    }
+    // Embeddable ID (first local embeddable found)
+    try {
+        const embeddablesDir = 'embeddables';
+        if (fs.existsSync(embeddablesDir)) {
+            const entries = fs.readdirSync(embeddablesDir, { withFileTypes: true });
+            const firstDir = entries.find((e) => e.isDirectory());
+            if (firstDir)
+                ctx.embeddableId = firstDir.name;
+        }
+    }
+    catch {
+        // ignore
+    }
+    // Last CLI command
+    try {
+        const last = getLastHistoryEntry();
+        if (last) {
+            ctx.lastCommand = { ...last };
+        }
+    }
+    catch {
+        // ignore
+    }
+    // Git branch
+    try {
+        ctx.gitBranch = execSync('git rev-parse --abbrev-ref HEAD', {
+            encoding: 'utf8',
+            timeout: 3000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        // not in a git repo
+    }
+    // Git dirty
+    try {
+        const status = execSync('git status --porcelain', {
+            encoding: 'utf8',
+            timeout: 3000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        ctx.gitDirty = status.length > 0;
+    }
+    catch {
+        // not in a git repo
+    }
+    // AI tool detection
+    ctx.aiTool = detectAiTool();
+    return ctx;
+}
+export function detectAiTool() {
+    const envChecks = [
+        ['CURSOR_', 'cursor'],
+        ['CLAUDE_', 'claude-code'],
+        ['WINDSURF_', 'windsurf'],
+    ];
+    for (const [prefix, name] of envChecks) {
+        for (const key of Object.keys(process.env)) {
+            if (key.startsWith(prefix))
+                return name;
+        }
+    }
+    const dirChecks = [
+        ['.cursor', 'cursor'],
+        ['.claude', 'claude-code'],
+        ['.windsurf', 'windsurf'],
+    ];
+    for (const [dir, name] of dirChecks) {
+        try {
+            if (fs.existsSync(path.join(process.cwd(), dir)))
+                return name;
+        }
+        catch {
+            // ignore
+        }
+    }
+    return undefined;
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,5 @@
+export declare function runInit(opts: {
+    projectId?: string;
+    yes?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAoIA,wBAAsB,OAAO,CAAC,IAAI,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,iBAkSxE"}