clipy-kit 0.1.0

package/dist/colors.js

@@ -0,0 +1,26 @@
+import { CliError } from './output.js';
+const NAMED = {
+    white: '#ffffff',
+    black: '#000000',
+    navy: '#1a365d',
+    red: '#c53030',
+    green: '#276749',
+    blue: '#2b6cb0',
+    yellow: '#d69e2e',
+    gray: '#718096',
+    grey: '#718096',
+    orange: '#dd6b20',
+    purple: '#6b46c1',
+};
+export function parseColor(input) {
+    const key = input.trim().toLowerCase();
+    const hex = (NAMED[key] ?? (key.startsWith('#') ? key : `#${key}`)).replace('#', '');
+    if (!/^[0-9a-fA-F]{6}$/.test(hex)) {
+        throw new CliError('VALIDATION_ERROR', `Invalid color: ${input}. Use #rrggbb or a name like white, navy.`);
+    }
+    return {
+        red: parseInt(hex.slice(0, 2), 16) / 255,
+        green: parseInt(hex.slice(2, 4), 16) / 255,
+        blue: parseInt(hex.slice(4, 6), 16) / 255,
+    };
+}

package/dist/host/doctor.d.ts

@@ -0,0 +1,17 @@
+export declare function clipyHome(): string;
+export declare function doctor(): {
+    ok: boolean;
+    onPath: boolean;
+    which?: string;
+    binDir: string;
+    node: string;
+    nodeOk: boolean;
+    configDir: string;
+    configWritable: boolean;
+    plugins: {
+        builtIn: string[];
+        planned: number;
+    };
+    hint?: string;
+};
+export declare function doctorErrorCode(result: ReturnType<typeof doctor>): string | undefined;

package/dist/host/doctor.js

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { allPlugins, BUILTIN } from '../plugins/catalog.js';
+import { binDir, pathHasDir } from './setup.js';
+export function clipyHome() {
+    return process.env.CLIPY_CONFIG_DIR || path.join(os.homedir(), '.config', 'clipy');
+}
+function whichClp() {
+    const result = spawnSync('which', ['clp'], { encoding: 'utf8' });
+    const loc = result.stdout?.trim();
+    return loc || undefined;
+}
+export function doctor() {
+    const node = process.version;
+    const major = Number(node.slice(1).split('.')[0]);
+    const nodeOk = major >= 20;
+    const dir = binDir();
+    const which = whichClp();
+    const onPath = pathHasDir(dir) || Boolean(which && path.resolve(path.dirname(which)) === path.resolve(dir));
+    const home = clipyHome();
+    let configWritable = false;
+    try {
+        fs.mkdirSync(home, { recursive: true });
+        fs.accessSync(home, fs.constants.W_OK);
+        configWritable = true;
+    }
+    catch {
+        configWritable = false;
+    }
+    const ok = onPath && nodeOk && configWritable;
+    return {
+        ok,
+        onPath,
+        which,
+        binDir: dir,
+        node,
+        nodeOk,
+        configDir: home,
+        configWritable,
+        plugins: { builtIn: BUILTIN.map((p) => p.name), planned: allPlugins().filter((p) => p.status === 'planned').length },
+        hint: onPath ? undefined : 'Run: clp setup',
+    };
+}
+export function doctorErrorCode(result) {
+    if (!result.onPath)
+        return 'PATH_REQUIRED';
+    if (!result.nodeOk)
+        return 'NODE_VERSION';
+    if (!result.configWritable)
+        return 'CONFIG_ERROR';
+    return undefined;
+}

package/dist/host/help.d.ts

@@ -0,0 +1,20 @@
+export declare function hostHelpJson(path?: string[]): unknown;
+export declare function sheetHelpJson(path?: string[]): unknown;
+export declare function printHumanHelp(path: string[]): void;
+export declare function printPluginListHuman(): void;
+export declare function printDoctorHuman(d: {
+    ok: boolean;
+    onPath: boolean;
+    which?: string;
+    binDir: string;
+    node: string;
+    nodeOk: boolean;
+    configDir: string;
+    configWritable: boolean;
+    hint?: string;
+}): void;
+export declare function printSetupHuman(result: {
+    bin: string;
+    hint?: string;
+    undo?: boolean;
+}): void;

package/dist/host/help.js

@@ -0,0 +1,142 @@
+import { BUILTIN, PLANNED, allPlugins } from '../plugins/catalog.js';
+import { COMMANDS, findSpec } from '../plugins/sheet/specs.js';
+import { c } from '../color.js';
+export function hostHelpJson(path = []) {
+    if (!path.length || (path.length === 1 && path[0] === 'plugin')) {
+        return {
+            name: 'clp',
+            description: 'Clipy. One PATH binary; plugins for Sheets and (later) Linear, GitHub, Jira. Never write API or OAuth code — run clp <plugin>.',
+            globalOptions: [
+                { flags: '--pretty', description: 'Pretty-print JSON' },
+                { flags: '--json', description: 'Machine JSON (default for data commands; use with setup/doctor/plugin list)' },
+                { flags: '--account <name>', description: 'Credential profile (plugin-specific)' },
+                { flags: '--dry-run', description: 'Preview writes' },
+                { flags: '--help --json', description: 'Machine-readable schema' },
+            ],
+            commands: [
+                { name: 'setup', description: 'Install clp on PATH (~/.local/bin) and optionally update shell rc' },
+                { name: 'doctor', description: 'Check PATH, Node, config, plugins' },
+                { name: 'plugin', description: 'list | add', subcommands: ['list', 'add'] },
+                { name: 'sheet', description: BUILTIN[0]?.description },
+            ],
+            plugins: allPlugins(),
+        };
+    }
+    if (path[0] === 'setup') {
+        return { name: 'setup', description: 'Install the clp shim on PATH', options: [{ flags: '--undo', description: 'Remove shim and PATH block' }] };
+    }
+    if (path[0] === 'doctor') {
+        return { name: 'doctor', description: 'Health check. JSON with --json. Colored text on TTY.' };
+    }
+    if (path[0] === 'plugin') {
+        return {
+            name: 'plugin',
+            subcommands: [
+                { name: 'list', description: 'Built-in and planned plugins' },
+                { name: 'add', description: 'Enable a plugin (v1: only sheet is built-in)', args: [{ name: 'name', required: true }] },
+            ],
+        };
+    }
+    return { error: { code: 'UNKNOWN_COMMAND', message: `No host command: ${path.join(' ')}`, commands: ['setup', 'doctor', 'plugin', 'sheet'] } };
+}
+export function sheetHelpJson(path = []) {
+    if (!path.length) {
+        return {
+            name: 'sheet',
+            description: 'Google Sheets plugin. Never write googleapis or OAuth — run clp sheet …',
+            commands: COMMANDS.map((spec) => ({
+                name: spec.name,
+                description: spec.description,
+                subcommands: spec.subcommands?.map((s) => s.name),
+            })),
+        };
+    }
+    const spec = findSpec(path);
+    if (!spec) {
+        return { error: { code: 'UNKNOWN_COMMAND', message: `No command: sheet ${path.join(' ')}`, commands: COMMANDS.map((c) => c.name) } };
+    }
+    return {
+        name: spec.name,
+        description: spec.description,
+        args: spec.args ?? [],
+        options: spec.options ?? [],
+        subcommands: spec.subcommands?.map((s) => ({
+            name: s.name,
+            description: s.description,
+            args: s.args ?? [],
+            options: s.options ?? [],
+        })),
+    };
+}
+export function printHumanHelp(path) {
+    if (path[0] === 'sheet') {
+        const specPath = path.slice(1);
+        if (specPath.length) {
+            const spec = findSpec(specPath);
+            if (!spec) {
+                console.log(c.err(`Unknown: clp sheet ${specPath.join(' ')}`));
+                return;
+            }
+            console.log(c.title(`clp sheet ${specPath.join(' ')}`));
+            console.log(c.dim(spec.description));
+            if (spec.options?.length) {
+                console.log(`\n${c.bold('Flags')}`);
+                for (const o of spec.options)
+                    console.log(`  ${c.plugin(o.flags)}  ${o.description}`);
+            }
+            return;
+        }
+        console.log(c.title('clp sheet') + c.dim('  Google Sheets'));
+        console.log(c.dim('JSON on stdout. Login: clp sheet auth login\n'));
+        for (const spec of COMMANDS) {
+            console.log(`  ${c.plugin(spec.name.padEnd(16))} ${spec.description}`);
+        }
+        console.log(`\n${c.dim('Schema: clp sheet <cmd> --help --json')}`);
+        return;
+    }
+    console.log(c.title('clp') + '  ' + c.dim('Clipy'));
+    console.log(c.dim('One binary for humans and agents. Never rewrite API or OAuth code.\n'));
+    console.log(c.bold('Commands'));
+    console.log(`  ${c.plugin('setup'.padEnd(16))} Install clp on PATH`);
+    console.log(`  ${c.plugin('doctor'.padEnd(16))} Check PATH, Node, config`);
+    console.log(`  ${c.plugin('plugin list'.padEnd(16))} Built-in and planned plugins`);
+    console.log(`  ${c.plugin('sheet …'.padEnd(16))} Google Sheets\n`);
+    console.log(c.bold('Plugins'));
+    for (const p of BUILTIN) {
+        console.log(`  ${c.ok('●')} ${c.plugin(p.name.padEnd(16))} ${p.description}`);
+    }
+    for (const p of PLANNED.slice(0, 6)) {
+        console.log(`  ${c.dim('○')} ${c.dim(p.name.padEnd(16))} ${c.dim(p.description + ' (planned)')}`);
+    }
+    console.log(c.dim(`  … ${Math.max(0, PLANNED.length - 6)} more planned. See: clp plugin list\n`));
+    console.log(c.dim('Machine schema: clp --help --json'));
+}
+export function printPluginListHuman() {
+    console.log(c.title('Plugins') + '\n');
+    console.log(c.bold('Built-in'));
+    for (const p of BUILTIN) {
+        console.log(`  ${c.ok('●')} ${c.plugin(p.name)}  ${p.description}`);
+    }
+    console.log(`\n${c.bold('Planned')} ${c.dim('(not installed — do not call)')}`);
+    for (const p of PLANNED) {
+        console.log(`  ${c.dim('○')} ${c.dim(p.name.padEnd(16))} ${c.dim(`[${p.when}] ${p.description}`)}`);
+    }
+}
+export function printDoctorHuman(d) {
+    const row = (ok, label, value) => `${ok ? c.ok('✔') : c.err('✖')} ${label.padEnd(16)} ${ok ? value : c.warn(value)}`;
+    console.log(c.title('clp doctor') + '\n');
+    console.log(row(d.nodeOk, 'Node', d.node));
+    console.log(row(d.onPath, 'PATH', d.which || d.binDir));
+    console.log(row(d.configWritable, 'Config', d.configDir));
+    console.log(`\n${d.ok ? c.ok('All good.') : c.warn(d.hint || 'See failures above.')}`);
+}
+export function printSetupHuman(result) {
+    if (result.undo) {
+        console.log(c.warn('Removed clp shim.') + (result.hint ? `\n${c.dim(result.hint)}` : ''));
+        return;
+    }
+    console.log(c.ok(`Installed ${result.bin}`));
+    if (result.hint)
+        console.log(c.dim(result.hint));
+    console.log(c.dim('Next: clp doctor'));
+}

package/dist/host/setup.d.ts

@@ -0,0 +1,16 @@
+export declare function binDir(): string;
+export declare function shellRcPath(): string;
+export declare function cliEntryPath(): string;
+export declare function pathHasDir(dir: string, pathEnv?: string): boolean;
+export type SetupResult = {
+    bin: string;
+    target: string;
+    shim: string;
+    pathConfigured: boolean;
+    rcUpdated?: string;
+    undo?: boolean;
+    hint?: string;
+};
+export declare function setup(opts?: {
+    undo?: boolean;
+}): SetupResult;

package/dist/host/setup.js

@@ -0,0 +1,93 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { CliError, EXIT } from '../output.js';
+const MARKER_START = '# clipy cli';
+const MARKER_END = '# end clipy cli';
+export function binDir() {
+    return process.env.CLIPY_BIN_DIR || path.join(os.homedir(), '.local', 'bin');
+}
+export function shellRcPath() {
+    if (process.env.CLIPY_SHELL_RC)
+        return process.env.CLIPY_SHELL_RC;
+    const shell = process.env.SHELL || '';
+    if (shell.includes('zsh'))
+        return path.join(os.homedir(), '.zshrc');
+    if (shell.includes('bash'))
+        return path.join(os.homedir(), '.bashrc');
+    return path.join(os.homedir(), '.zshrc');
+}
+export function cliEntryPath() {
+    if (process.env.CLIPY_CLI_ENTRY)
+        return process.env.CLIPY_CLI_ENTRY;
+    const here = fileURLToPath(import.meta.url);
+    if (here.endsWith('.ts')) {
+        return path.resolve(path.dirname(here), '../../dist/cli.js');
+    }
+    return path.resolve(path.dirname(here), '../cli.js');
+}
+function pathLine(dir) {
+    return `export PATH="${dir}:$PATH"`;
+}
+export function pathHasDir(dir, pathEnv = process.env.PATH ?? '') {
+    const parts = pathEnv.split(path.delimiter).filter(Boolean);
+    const resolved = path.resolve(dir);
+    return parts.some((p) => path.resolve(p) === resolved);
+}
+function ensureMarkerBlock(rc, dir) {
+    const block = `${MARKER_START}\n${pathLine(dir)}\n${MARKER_END}\n`;
+    if (!fs.existsSync(rc)) {
+        fs.writeFileSync(rc, `\n${block}`, 'utf8');
+        return { written: true, rc };
+    }
+    const text = fs.readFileSync(rc, 'utf8');
+    if (text.includes(MARKER_START))
+        return { written: false, rc };
+    fs.appendFileSync(rc, `\n${block}`);
+    return { written: true, rc };
+}
+function removeMarkerBlock(rc) {
+    if (!fs.existsSync(rc))
+        return false;
+    const text = fs.readFileSync(rc, 'utf8');
+    const re = new RegExp(`\\n?${MARKER_START}[\\s\\S]*?${MARKER_END}\\n?`);
+    if (!re.test(text))
+        return false;
+    fs.writeFileSync(rc, text.replace(re, '\n'), 'utf8');
+    return true;
+}
+export function setup(opts = {}) {
+    const dir = binDir();
+    const bin = path.join(dir, 'clp');
+    if (opts.undo) {
+        if (fs.existsSync(bin))
+            fs.unlinkSync(bin);
+        const removed = removeMarkerBlock(shellRcPath());
+        return { bin, target: cliEntryPath(), shim: bin, pathConfigured: pathHasDir(dir), undo: true, hint: removed ? 'Removed PATH block from shell rc' : 'No PATH block found' };
+    }
+    const target = cliEntryPath();
+    if (!fs.existsSync(target)) {
+        throw new CliError('SETUP_ERROR', `CLI entry not found at ${target}. Run npm run build first.`, { target }, EXIT.VALIDATION);
+    }
+    fs.mkdirSync(dir, { recursive: true });
+    const shim = `#!/usr/bin/env bash\nexec node ${JSON.stringify(target)} "$@"\n`;
+    fs.writeFileSync(bin, shim, { mode: 0o755 });
+    let rcUpdated;
+    let pathConfigured = pathHasDir(dir);
+    if (!pathConfigured) {
+        const upd = ensureMarkerBlock(shellRcPath(), dir);
+        rcUpdated = upd.rc;
+        pathConfigured = true;
+    }
+    return {
+        bin,
+        target,
+        shim: bin,
+        pathConfigured,
+        rcUpdated,
+        hint: rcUpdated
+            ? `Added PATH in ${rcUpdated}. Open a new terminal or: source ${rcUpdated}`
+            : `clp is at ${bin}`,
+    };
+}

package/dist/http.d.ts

@@ -0,0 +1,14 @@
+export declare class GoogleClient {
+    private readonly getToken;
+    private readonly fetchImpl;
+    constructor(getToken: () => Promise<string>, fetchImpl?: typeof fetch);
+    sheets<T>(method: string, path: string, opts?: {
+        query?: Record<string, string | undefined>;
+        body?: unknown;
+    }): Promise<T>;
+    drive<T>(method: string, path: string, opts?: {
+        query?: Record<string, string | undefined>;
+        body?: unknown;
+    }): Promise<T>;
+    private request;
+}

package/dist/http.js

@@ -0,0 +1,53 @@
+import { CliError, EXIT } from './output.js';
+export class GoogleClient {
+    getToken;
+    fetchImpl;
+    constructor(getToken, fetchImpl = fetch) {
+        this.getToken = getToken;
+        this.fetchImpl = fetchImpl;
+    }
+    async sheets(method, path, opts = {}) {
+        return this.request('https://sheets.googleapis.com/v4', method, path, opts);
+    }
+    async drive(method, path, opts = {}) {
+        return this.request('https://www.googleapis.com/drive/v3', method, path, opts);
+    }
+    async request(base, method, path, opts) {
+        const url = new URL(path.startsWith('http') ? path : `${base}${path}`);
+        for (const [k, v] of Object.entries(opts.query ?? {})) {
+            if (v !== undefined)
+                url.searchParams.set(k, v);
+        }
+        const token = await this.getToken();
+        const res = await this.fetchImpl(url, {
+            method,
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+            },
+            body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+        });
+        const text = await res.text();
+        let json = undefined;
+        if (text) {
+            try {
+                json = JSON.parse(text);
+            }
+            catch {
+                json = { message: text };
+            }
+        }
+        if (!res.ok) {
+            const apiErr = json;
+            const message = apiErr.error?.message || `Google API ${res.status} ${res.statusText}`;
+            if (res.status === 401) {
+                throw new CliError('AUTH_REQUIRED', 'Run: clp sheet auth login', { status: 401, message }, EXIT.AUTH);
+            }
+            if (res.status === 403) {
+                throw new CliError('PERMISSION_ERROR', message, { status: 403 }, EXIT.PERMISSION);
+            }
+            throw new CliError('API_ERROR', message, { status: res.status, body: json }, EXIT.API);
+        }
+        return (json ?? {});
+    }
+}

package/dist/ids.d.ts

@@ -0,0 +1,2 @@
+export declare function parseSpreadsheetId(input: string): string;
+export declare function resolveSpreadsheetId(positional?: string, flag?: string): string;

package/dist/ids.js

@@ -0,0 +1,21 @@
+import { CliError } from './output.js';
+const ID_RE = /\/spreadsheets\/d\/([a-zA-Z0-9-_]+)/;
+export function parseSpreadsheetId(input) {
+    const trimmed = input.trim();
+    const match = trimmed.match(ID_RE);
+    if (match)
+        return match[1];
+    if (!trimmed)
+        throw new CliError('VALIDATION_ERROR', 'Spreadsheet ID or URL is required');
+    if (/^[a-zA-Z0-9-_]{20,}$/.test(trimmed) || /^[a-zA-Z0-9-_]+$/.test(trimmed)) {
+        return trimmed;
+    }
+    throw new CliError('VALIDATION_ERROR', `Could not parse spreadsheet ID from: ${input}`);
+}
+export function resolveSpreadsheetId(positional, flag) {
+    const raw = positional || flag;
+    if (!raw) {
+        throw new CliError('VALIDATION_ERROR', 'Pass a spreadsheet ID/URL as the argument or --spreadsheet');
+    }
+    return parseSpreadsheetId(raw);
+}

package/dist/json-input.d.ts

@@ -0,0 +1,4 @@
+export declare function parseJsonInput(raw: string, label: string): unknown;
+export declare function asObject(value: unknown, label: string): Record<string, unknown>;
+export declare function asObjectArray(value: unknown, label: string): Record<string, unknown>[];
+export declare function asGrid(value: unknown, label: string): unknown[][];

package/dist/json-input.js

@@ -0,0 +1,34 @@
+import fs from 'node:fs';
+import { CliError } from './output.js';
+export function parseJsonInput(raw, label) {
+    const text = raw.startsWith('@')
+        ? fs.readFileSync(raw.slice(1), 'utf8')
+        : raw;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new CliError('VALIDATION_ERROR', `${label} is not valid JSON${raw.startsWith('@') ? ` (file ${raw.slice(1)})` : ''}`);
+    }
+}
+export function asObject(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new CliError('VALIDATION_ERROR', `${label} must be a JSON object`);
+    }
+    return value;
+}
+export function asObjectArray(value, label) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return [value];
+    }
+    if (!Array.isArray(value) || value.some((row) => !row || typeof row !== 'object' || Array.isArray(row))) {
+        throw new CliError('VALIDATION_ERROR', `${label} must be a JSON object or array of objects`);
+    }
+    return value;
+}
+export function asGrid(value, label) {
+    if (!Array.isArray(value) || value.some((row) => !Array.isArray(row))) {
+        throw new CliError('VALIDATION_ERROR', `${label} must be a JSON 2D array`);
+    }
+    return value;
+}

package/dist/lib/format.d.ts

@@ -0,0 +1,14 @@
+import type { GridRange } from '../ranges.js';
+export type FormatFlags = {
+    bold?: boolean;
+    italic?: boolean;
+    bg?: string;
+    fg?: string;
+    align?: string;
+    valign?: string;
+    pattern?: string;
+    wrap?: boolean;
+};
+export declare function formatFields(flags: FormatFlags): string[];
+export declare function formatToRepeatCell(range: GridRange, flags: FormatFlags): Record<string, unknown>;
+export declare function freezeRequest(sheetId: number, rows?: number, columns?: number): Record<string, unknown>;

package/dist/lib/format.js

@@ -0,0 +1,73 @@
+import { parseColor } from '../colors.js';
+export function formatFields(flags) {
+    const fields = [];
+    if (flags.bold !== undefined || flags.italic !== undefined || flags.fg) {
+        const parts = ['textFormat'];
+        if (flags.bold !== undefined)
+            parts.push('textFormat.bold');
+        if (flags.italic !== undefined)
+            parts.push('textFormat.italic');
+        if (flags.fg)
+            parts.push('textFormat.foregroundColor');
+        fields.push(...parts);
+    }
+    if (flags.bg)
+        fields.push('backgroundColor');
+    if (flags.align)
+        fields.push('horizontalAlignment');
+    if (flags.valign)
+        fields.push('verticalAlignment');
+    if (flags.pattern)
+        fields.push('numberFormat');
+    if (flags.wrap !== undefined)
+        fields.push('wrapStrategy');
+    return fields;
+}
+export function formatToRepeatCell(range, flags) {
+    const fmt = {};
+    if (flags.bold !== undefined || flags.italic !== undefined || flags.fg) {
+        fmt.textFormat = {};
+        if (flags.bold !== undefined)
+            fmt.textFormat.bold = flags.bold;
+        if (flags.italic !== undefined)
+            fmt.textFormat.italic = flags.italic;
+        if (flags.fg)
+            fmt.textFormat.foregroundColor = parseColor(flags.fg);
+    }
+    if (flags.bg)
+        fmt.backgroundColor = parseColor(flags.bg);
+    if (flags.align)
+        fmt.horizontalAlignment = flags.align.toUpperCase();
+    if (flags.valign)
+        fmt.verticalAlignment = flags.valign.toUpperCase();
+    if (flags.pattern)
+        fmt.numberFormat = { type: 'NUMBER', pattern: flags.pattern };
+    if (flags.wrap !== undefined)
+        fmt.wrapStrategy = flags.wrap ? 'WRAP' : 'OVERFLOW_CELL';
+    const fieldList = formatFields(flags).map((f) => `userEnteredFormat.${f}`);
+    return {
+        repeatCell: {
+            range,
+            cell: { userEnteredFormat: fmt },
+            fields: fieldList.join(','),
+        },
+    };
+}
+export function freezeRequest(sheetId, rows, columns) {
+    const gridProperties = {};
+    const fields = [];
+    if (rows !== undefined) {
+        gridProperties.frozenRowCount = rows;
+        fields.push('gridProperties.frozenRowCount');
+    }
+    if (columns !== undefined) {
+        gridProperties.frozenColumnCount = columns;
+        fields.push('gridProperties.frozenColumnCount');
+    }
+    return {
+        updateSheetProperties: {
+            properties: { sheetId, gridProperties },
+            fields: fields.join(','),
+        },
+    };
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,6 @@
+export { parseSpreadsheetId } from '../ids.js';
+export { GoogleClient } from '../http.js';
+export { createOps } from './ops.js';
+export { valuesToTable, objectToRow } from './table.js';
+export { formatToRepeatCell, freezeRequest } from './format.js';
+export { getAccessToken, login, logout, status } from '../auth.js';

package/dist/lib/index.js

@@ -0,0 +1,6 @@
+export { parseSpreadsheetId } from '../ids.js';
+export { GoogleClient } from '../http.js';
+export { createOps } from './ops.js';
+export { valuesToTable, objectToRow } from './table.js';
+export { formatToRepeatCell, freezeRequest } from './format.js';
+export { getAccessToken, login, logout, status } from '../auth.js';