@skhema/cli 0.3.1

package/dist/lib/contribute/method-schema.js

@@ -0,0 +1,172 @@
+/**
+ * Vendored from @skhema/types (src/schema/{elements,components,mapping}.ts).
+ *
+ * @skhema/types is a restricted npm package; @skhema/cli is public, so it must
+ * not depend on it at install time. This is the public method vocabulary (it
+ * renders verbatim in public embeds) — keep it in sync with @skhema/types when
+ * the method schema changes.
+ */
+export const ELEMENT_TYPES = {
+    KEY_CHALLENGE: {
+        value: 'key_challenge',
+        label: 'Key Challenge',
+        acronym: 'CHL',
+    },
+    SUPPORTING_FACT: {
+        value: 'supporting_fact',
+        label: 'Supporting Fact',
+        acronym: 'FCT',
+    },
+    IMPACT: {
+        value: 'impact',
+        label: 'Impact',
+        acronym: 'IMP',
+    },
+    GUIDING_POLICY: {
+        value: 'guiding_policy',
+        label: 'Guiding Policy',
+        acronym: 'POL',
+    },
+    COMPETITOR_MOVE: {
+        value: 'competitor_move',
+        label: 'Competitor Move',
+        acronym: 'CMV',
+    },
+    SCOPE: {
+        value: 'scope',
+        label: 'Scope',
+        acronym: 'SCP',
+    },
+    CONSTRAINT: {
+        value: 'constraint',
+        label: 'Constraint',
+        acronym: 'CST',
+    },
+    SOLUTION: {
+        value: 'solution',
+        label: 'Solution',
+        acronym: 'SOL',
+    },
+    ASSUMPTION_HYPOTHESIS: {
+        value: 'assumption_hypothesis',
+        label: 'Assumption Hypothesis',
+        acronym: 'HYP',
+    },
+    EXPERIMENT: {
+        value: 'experiment',
+        label: 'Experiment',
+        acronym: 'EXP',
+    },
+    ACTION: {
+        value: 'action',
+        label: 'Action',
+        acronym: 'ACT',
+    },
+    INVESTMENT: {
+        value: 'investment',
+        label: 'Investment',
+        acronym: 'INV',
+    },
+    ESTIMATE: {
+        value: 'estimate',
+        label: 'Estimate',
+        acronym: 'EST',
+    },
+    BASELINE: {
+        value: 'baseline',
+        label: 'Baseline',
+        acronym: 'BSL',
+    },
+    OUTCOME: {
+        value: 'outcome',
+        label: 'Outcome',
+        acronym: 'OCM',
+    },
+    PERFORMANCE_VARIABLE: {
+        value: 'performance_variable',
+        label: 'Performance Variable',
+        acronym: 'VAR',
+    },
+    CAPABILITY: {
+        value: 'capability',
+        label: 'Capability',
+        acronym: 'CAP',
+    },
+    SYSTEM: {
+        value: 'system',
+        label: 'System',
+        acronym: 'SYS',
+    },
+    PRINCIPLE: {
+        value: 'principle',
+        label: 'Principle',
+        acronym: 'PRN',
+    },
+};
+export const COMPONENT_TYPES = {
+    DIAGNOSIS: {
+        value: 'diagnosis',
+        label: 'Diagnosis',
+        acronym: 'BD',
+    },
+    METHOD: {
+        value: 'method',
+        label: 'Method & Positioning',
+        acronym: 'MP',
+    },
+    INITIATIVES: {
+        value: 'initiatives',
+        label: 'Portfolio of Initiatives',
+        acronym: 'PI',
+    },
+    MEASURES: {
+        value: 'measures',
+        label: 'Measures',
+        acronym: 'M',
+    },
+    SUPPORT: {
+        value: 'support',
+        label: 'Support Structures',
+        acronym: 'SS',
+    },
+};
+export const SKHEMA_MAPPING = {
+    componentFlow: [
+        COMPONENT_TYPES.DIAGNOSIS,
+        COMPONENT_TYPES.METHOD,
+        COMPONENT_TYPES.INITIATIVES,
+        COMPONENT_TYPES.MEASURES,
+        COMPONENT_TYPES.SUPPORT,
+    ],
+    elementFlow: {
+        [COMPONENT_TYPES.DIAGNOSIS.value]: [
+            ELEMENT_TYPES.KEY_CHALLENGE,
+            ELEMENT_TYPES.SUPPORTING_FACT,
+            ELEMENT_TYPES.IMPACT,
+        ],
+        [COMPONENT_TYPES.METHOD.value]: [
+            ELEMENT_TYPES.GUIDING_POLICY,
+            ELEMENT_TYPES.COMPETITOR_MOVE,
+            ELEMENT_TYPES.SCOPE,
+            ELEMENT_TYPES.CONSTRAINT,
+        ],
+        [COMPONENT_TYPES.INITIATIVES.value]: [
+            ELEMENT_TYPES.SOLUTION,
+            ELEMENT_TYPES.ASSUMPTION_HYPOTHESIS,
+            ELEMENT_TYPES.EXPERIMENT,
+            ELEMENT_TYPES.ACTION,
+            ELEMENT_TYPES.ESTIMATE,
+            ELEMENT_TYPES.INVESTMENT,
+        ],
+        [COMPONENT_TYPES.MEASURES.value]: [
+            ELEMENT_TYPES.BASELINE,
+            ELEMENT_TYPES.OUTCOME,
+            ELEMENT_TYPES.PERFORMANCE_VARIABLE,
+        ],
+        [COMPONENT_TYPES.SUPPORT.value]: [
+            ELEMENT_TYPES.CAPABILITY,
+            ELEMENT_TYPES.SYSTEM,
+            ELEMENT_TYPES.PRINCIPLE,
+        ],
+    },
+};

package/dist/lib/contribute/profile-resolver.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveContributorDisplayName(contributorId: string, accessToken: string): Promise<string | null>;
+//# sourceMappingURL=profile-resolver.d.ts.map

package/dist/lib/contribute/profile-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile-resolver.d.ts","sourceRoot":"","sources":["../../../src/lib/contribute/profile-resolver.ts"],"names":[],"mappings":"AAIA,wBAAsB,6BAA6B,CACjD,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsBxB"}

package/dist/lib/contribute/profile-resolver.js

@@ -0,0 +1,25 @@
+import { SUPABASE_PUBLISHABLE_KEY, SUPABASE_URL } from '../config.js';
+const CONTRIBUTOR_MANAGE_URL = `${SUPABASE_URL}/functions/v1/contributor-manage`;
+export async function resolveContributorDisplayName(contributorId, accessToken) {
+    try {
+        const response = await fetch(CONTRIBUTOR_MANAGE_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+                apikey: SUPABASE_PUBLISHABLE_KEY,
+            },
+            body: JSON.stringify({
+                action: 'resolve-display-name',
+                contributor_id: contributorId,
+            }),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        return data.displayName || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/contribute/types.d.ts

@@ -0,0 +1,91 @@
+export interface GenerateEmbedOptions {
+    elementType: string;
+    contributorId: string;
+    authorName?: string;
+    authorSlug?: string;
+    content: string;
+    theme?: 'light' | 'dark' | 'auto';
+    trackAnalytics?: boolean;
+    sourceUrl?: string;
+}
+export interface GenerateLinkOptions {
+    elementType: string;
+    contributorId: string;
+    content: string;
+    sourceUrl?: string;
+    utmSource?: string;
+    utmMedium?: string;
+    utmCampaign?: string;
+}
+export interface GenerateEmbedResult {
+    snippet: string;
+    cdnUrl: string;
+    attributes: Record<string, string>;
+}
+export interface GenerateLinkResult {
+    url: string;
+    contentHash: string;
+}
+export interface GenerateComponentEmbedOptions {
+    componentType: string;
+    contributorId: string;
+    authorName?: string;
+    authorSlug?: string;
+    elements: Array<{
+        elementType: string;
+        content: string;
+    }>;
+    title?: string;
+    theme?: 'light' | 'dark' | 'auto';
+    trackAnalytics?: boolean;
+    sourceUrl?: string;
+}
+export interface GenerateComponentEmbedResult {
+    snippet: string;
+    cdnUrl: string;
+    attributes: Record<string, string>;
+    elementCount: number;
+}
+export interface GenerateComponentLinkOptions {
+    componentType: string;
+    contributorId: string;
+    elements: Array<{
+        elementType: string;
+        content: string;
+    }>;
+    title?: string;
+    sourceUrl?: string;
+    utmSource?: string;
+    utmMedium?: string;
+    utmCampaign?: string;
+}
+export interface GenerateComponentLinkResult {
+    url: string;
+    componentHash: string;
+}
+export interface PublishShareLinkOptions {
+    contributorId: string;
+    elementType: string;
+    content: string;
+    accessToken: string;
+}
+export interface PublishShareLinkResult {
+    shareUrl: string;
+    elementId: string;
+    contentHash: string;
+}
+export interface PublishComponentShareLinkOptions {
+    contributorId: string;
+    componentType: string;
+    title?: string;
+    elements: Array<{
+        elementType: string;
+        content: string;
+    }>;
+    accessToken: string;
+}
+export interface PublishComponentShareLinkResult {
+    shareUrl: string;
+    componentId: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/contribute/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/contribute/types.ts"],"names":[],"mappings":"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"}

package/dist/lib/contribute/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/mcp/registrar.d.ts

@@ -0,0 +1,26 @@
+import { McpStatus, McpTarget } from './registry.js';
+/**
+ * Inspect a target without touching disk: what would registering do right now?
+ * Returns `not-detected` for absent clients and defers to {@link planMerge} for
+ * the rest.
+ */
+export declare function inspectTarget(target: McpTarget): McpStatus;
+export interface McpRegisterOutcome {
+    status: McpStatus;
+    configPath?: string;
+    /** Path of the `.bak` copy written before an existing file was modified. */
+    backupPath?: string;
+    /** Present when status is `conflict` or `manual` — how to finish by hand. */
+    instructions?: string;
+}
+/**
+ * Safely register the Skhema MCP server in one target. Parses + merges the
+ * existing config, writes a `<file>.bak` backup next to any file it modifies,
+ * and writes pretty-printed JSON. Never overwrites a differing `skhema` entry
+ * unless `force` is set. Returns instructions (does not throw) when the config
+ * can't be written safely.
+ */
+export declare function registerTarget(target: McpTarget, options?: {
+    force?: boolean;
+}): McpRegisterOutcome;
+//# sourceMappingURL=registrar.d.ts.map

package/dist/lib/mcp/registrar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registrar.d.ts","sourceRoot":"","sources":["../../../src/lib/mcp/registrar.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,SAAS,EAAE,SAAS,EAAa,MAAM,eAAe,CAAA;AAUhF;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,CAK1D;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,SAAS,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,6EAA6E;IAC7E,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,SAAS,EACjB,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAChC,kBAAkB,CA2CpB"}

package/dist/lib/mcp/registrar.js

@@ -0,0 +1,69 @@
+import fs from 'fs';
+import path from 'path';
+import { MCP_SERVER_NAME, planMerge } from './registry.js';
+function readIfExists(p) {
+    try {
+        return fs.readFileSync(p, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Inspect a target without touching disk: what would registering do right now?
+ * Returns `not-detected` for absent clients and defers to {@link planMerge} for
+ * the rest.
+ */
+export function inspectTarget(target) {
+    if (!target.detected)
+        return 'not-detected';
+    if (!target.configPath)
+        return 'manual';
+    const raw = readIfExists(target.configPath);
+    return planMerge(raw, target.parentKey, MCP_SERVER_NAME, target.entry).status;
+}
+/**
+ * Safely register the Skhema MCP server in one target. Parses + merges the
+ * existing config, writes a `<file>.bak` backup next to any file it modifies,
+ * and writes pretty-printed JSON. Never overwrites a differing `skhema` entry
+ * unless `force` is set. Returns instructions (does not throw) when the config
+ * can't be written safely.
+ */
+export function registerTarget(target, options = {}) {
+    if (!target.detected)
+        return { status: 'not-detected' };
+    if (!target.configPath) {
+        return { status: 'manual', instructions: target.instructions };
+    }
+    const raw = readIfExists(target.configPath);
+    const plan = planMerge(raw, target.parentKey, MCP_SERVER_NAME, target.entry);
+    if (plan.status === 'already') {
+        return { status: 'already', configPath: target.configPath };
+    }
+    if (plan.status === 'manual') {
+        return {
+            status: 'manual',
+            configPath: target.configPath,
+            instructions: target.instructions,
+        };
+    }
+    if (plan.status === 'conflict' && !options.force) {
+        return {
+            status: 'conflict',
+            configPath: target.configPath,
+            instructions: target.instructions,
+        };
+    }
+    // A forced conflict re-plans against an empty base so the entry is overwritten.
+    const merged = plan.status === 'writable'
+        ? plan.merged
+        : planMerge('{}', target.parentKey, MCP_SERVER_NAME, target.entry).merged;
+    let backupPath;
+    if (raw !== null) {
+        backupPath = `${target.configPath}.bak`;
+        fs.writeFileSync(backupPath, raw);
+    }
+    fs.mkdirSync(path.dirname(target.configPath), { recursive: true });
+    fs.writeFileSync(target.configPath, JSON.stringify(merged, null, 2) + '\n');
+    return { status: 'registered', configPath: target.configPath, backupPath };
+}

package/dist/lib/mcp/registry.d.ts

@@ -0,0 +1,54 @@
+/** The server key written into each client's `mcpServers` map. */
+export declare const MCP_SERVER_NAME = "skhema";
+/**
+ * A known MCP client and where/how to register the Skhema server in it.
+ *
+ * `configPath: null` (or a client whose config we can't safely parse) means we
+ * never mutate — we print copy-paste `instructions` instead. This is the safety
+ * bias: corrupting a user's config is worse than asking them to paste one block.
+ */
+export interface McpTarget {
+    id: string;
+    name: string;
+    /** True when the client appears installed (its config dir/file exists). */
+    detected: boolean;
+    /**
+     * Dedicated JSON config file we can parse + merge + back up, or `null` when the
+     * client has no cleanly-writable file (GUI apps, shared configs) → instructions.
+     */
+    configPath: string | null;
+    /** Object key the server entry nests under (usually `mcpServers`). */
+    parentKey: string;
+    /** The server-entry value in this client's schema (e.g. `{ url }`). */
+    entry: Record<string, unknown>;
+    /** Copy-paste guidance shown when we don't or can't write the config. */
+    instructions: string;
+}
+/**
+ * Build the MCP target list for the current machine. Detection is filesystem
+ * presence of each client's config directory; `configPath` points at a dedicated
+ * MCP JSON file where one exists.
+ */
+export declare function detectMcpTargets(serverUrl?: string, home?: string, cwd?: string): McpTarget[];
+/**
+ * The outcome of inspecting (or attempting to write) a target's config.
+ * - `not-detected` — client not installed.
+ * - `already` — our server entry is present and identical (idempotent no-op).
+ * - `writable` — absent; a safe merge would add it.
+ * - `registered` — we merged + wrote it this run.
+ * - `conflict` — a different `skhema` entry exists; left untouched (needs --force).
+ * - `manual` — existing config isn't cleanly parseable → instructions only.
+ */
+export type McpStatus = 'not-detected' | 'already' | 'writable' | 'registered' | 'conflict' | 'manual';
+export interface McpMergeResult {
+    status: Exclude<McpStatus, 'registered' | 'not-detected'>;
+    /** The merged config to write (only meaningful when status is `writable`). */
+    merged?: Record<string, unknown>;
+}
+/**
+ * Pure core: given the existing raw config text (or `null` when absent), decide
+ * what registering the Skhema server would do, and produce the merged object
+ * when a write is safe. Never performs I/O.
+ */
+export declare function planMerge(existingRaw: string | null, parentKey: string, serverName: string, entry: Record<string, unknown>): McpMergeResult;
+//# sourceMappingURL=registry.d.ts.map

package/dist/lib/mcp/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/lib/mcp/registry.ts"],"names":[],"mappings":"AAKA,kEAAkE;AAClE,eAAO,MAAM,eAAe,WAAW,CAAA;AAEvC;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,2EAA2E;IAC3E,QAAQ,EAAE,OAAO,CAAA;IACjB;;;OAGG;IACH,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAA;IACjB,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,yEAAyE;IACzE,YAAY,EAAE,MAAM,CAAA;CACrB;AAUD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,GAAE,MAAuB,EAClC,IAAI,GAAE,MAAqB,EAC3B,GAAG,GAAE,MAAsB,GAC1B,SAAS,EAAE,CA+Cb;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GACjB,cAAc,GACd,SAAS,GACT,UAAU,GACV,YAAY,GACZ,UAAU,GACV,QAAQ,CAAA;AAEZ,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,OAAO,CAAC,SAAS,EAAE,YAAY,GAAG,cAAc,CAAC,CAAA;IACzD,8EAA8E;IAC9E,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACjC;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,cAAc,CAsChB"}

package/dist/lib/mcp/registry.js

@@ -0,0 +1,105 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { MCP_SERVER_URL } from '../config.js';
+/** The server key written into each client's `mcpServers` map. */
+export const MCP_SERVER_NAME = 'skhema';
+function exists(p) {
+    try {
+        return fs.existsSync(p);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Build the MCP target list for the current machine. Detection is filesystem
+ * presence of each client's config directory; `configPath` points at a dedicated
+ * MCP JSON file where one exists.
+ */
+export function detectMcpTargets(serverUrl = MCP_SERVER_URL, home = os.homedir(), cwd = process.cwd()) {
+    const claudeConfig = path.join(home, '.claude');
+    const cursorDir = path.join(home, '.cursor');
+    const windsurfDir = path.join(home, '.codeium', 'windsurf');
+    const geminiDir = path.join(home, '.gemini');
+    return [
+        {
+            id: 'claude',
+            name: 'Claude Code',
+            detected: exists(claudeConfig) || exists(path.join(cwd, '.mcp.json')),
+            // Claude Code's user config (~/.claude.json) is large, project-keyed shared
+            // state — not cleanly mergeable. Register the project-scoped `.mcp.json` in
+            // the working directory instead (a dedicated, low-risk file).
+            configPath: path.join(cwd, '.mcp.json'),
+            parentKey: 'mcpServers',
+            entry: { type: 'http', url: serverUrl },
+            instructions: `claude mcp add --transport http ${MCP_SERVER_NAME} ${serverUrl}`,
+        },
+        {
+            id: 'cursor',
+            name: 'Cursor',
+            detected: exists(cursorDir),
+            configPath: path.join(cursorDir, 'mcp.json'),
+            parentKey: 'mcpServers',
+            entry: { url: serverUrl },
+            instructions: `Add to ~/.cursor/mcp.json → mcpServers.${MCP_SERVER_NAME} = { "url": "${serverUrl}" }`,
+        },
+        {
+            id: 'windsurf',
+            name: 'Windsurf',
+            detected: exists(windsurfDir),
+            configPath: path.join(windsurfDir, 'mcp_config.json'),
+            parentKey: 'mcpServers',
+            entry: { serverUrl },
+            instructions: `Add to ~/.codeium/windsurf/mcp_config.json → mcpServers.${MCP_SERVER_NAME} = { "serverUrl": "${serverUrl}" }`,
+        },
+        {
+            id: 'gemini',
+            name: 'Gemini CLI',
+            detected: exists(geminiDir),
+            configPath: path.join(geminiDir, 'settings.json'),
+            parentKey: 'mcpServers',
+            entry: { httpUrl: serverUrl },
+            instructions: `Add to ~/.gemini/settings.json → mcpServers.${MCP_SERVER_NAME} = { "httpUrl": "${serverUrl}" }`,
+        },
+    ];
+}
+/**
+ * Pure core: given the existing raw config text (or `null` when absent), decide
+ * what registering the Skhema server would do, and produce the merged object
+ * when a write is safe. Never performs I/O.
+ */
+export function planMerge(existingRaw, parentKey, serverName, entry) {
+    let config = {};
+    if (existingRaw !== null && existingRaw.trim() !== '') {
+        let parsed;
+        try {
+            parsed = JSON.parse(existingRaw);
+        }
+        catch {
+            return { status: 'manual' };
+        }
+        if (parsed === null ||
+            typeof parsed !== 'object' ||
+            Array.isArray(parsed)) {
+            return { status: 'manual' };
+        }
+        config = parsed;
+    }
+    const parent = config[parentKey];
+    const parentObj = parent && typeof parent === 'object' && !Array.isArray(parent)
+        ? parent
+        : {};
+    const current = parentObj[serverName];
+    if (current !== undefined) {
+        if (JSON.stringify(current) === JSON.stringify(entry)) {
+            return { status: 'already' };
+        }
+        return { status: 'conflict' };
+    }
+    const merged = {
+        ...config,
+        [parentKey]: { ...parentObj, [serverName]: entry },
+    };
+    return { status: 'writable', merged };
+}

package/dist/lib/open.d.ts

@@ -0,0 +1,2 @@
+export declare function openBrowser(url: string): Promise<void>;
+//# sourceMappingURL=open.d.ts.map

package/dist/lib/open.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open.d.ts","sourceRoot":"","sources":["../../src/lib/open.ts"],"names":[],"mappings":"AAEA,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBtD"}

package/dist/lib/open.js

@@ -0,0 +1,24 @@
+import { exec } from 'child_process';
+export function openBrowser(url) {
+    return new Promise((resolve, reject) => {
+        const platform = process.platform;
+        let command;
+        if (platform === 'darwin') {
+            command = `open "${url}"`;
+        }
+        else if (platform === 'win32') {
+            command = `start "" "${url}"`;
+        }
+        else {
+            command = `xdg-open "${url}"`;
+        }
+        exec(command, (error) => {
+            if (error) {
+                reject(new Error(`Failed to open browser: ${error.message}`));
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}

package/dist/lib/output.d.ts

@@ -0,0 +1,25 @@
+export interface CliResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    metadata?: {
+        timestamp: string;
+        command?: string;
+        [key: string]: unknown;
+    };
+}
+export interface OutputOptions {
+    json?: boolean;
+    verbose?: boolean;
+    quiet?: boolean;
+}
+export declare function setGlobalOptions(options: OutputOptions): void;
+export declare function getGlobalOptions(): OutputOptions;
+export declare function formatResult<T>(result: CliResult<T>): string;
+export declare function outputSuccess<T>(data: T, command?: string): void;
+export declare function outputError(error: string, command?: string): void;
+export declare function log(message: string): void;
+export declare function logVerbose(message: string): void;
+export declare function logHeader(title: string): void;
+export declare function logTable(headers: string[], rows: string[][], columnWidths?: number[]): void;
+//# sourceMappingURL=output.d.ts.map

package/dist/lib/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../src/lib/output.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,OAAO;IACpC,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,CAAC,EAAE,CAAC,CAAA;IACR,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE;QACT,SAAS,EAAE,MAAM,CAAA;QACjB,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KACvB,CAAA;CACF;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAID,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAE7D;AAED,wBAAgB,gBAAgB,IAAI,aAAa,CAEhD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAU5D;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAahE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAejE;AAED,wBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAIzC;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAIhD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAI7C;AAED,wBAAgB,QAAQ,CACtB,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,MAAM,EAAE,EAAE,EAChB,YAAY,CAAC,EAAE,MAAM,EAAE,GACtB,IAAI,CAmBN"}