@formo/cli 0.1.0

package/dist/commands/contracts.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contracts = void 0;
+exports.listContractsRun = listContractsRun;
+exports.createContractRun = createContractRun;
+exports.updateContractRun = updateContractRun;
+exports.deleteContractRun = deleteContractRun;
+const incur_1 = require("incur");
+const client_1 = require("../lib/client");
+exports.contracts = incur_1.Cli.create('contracts', {
+    description: 'Smart contract commands — register, list, update, and remove tracked contracts',
+});
+// ── List contracts ──
+function listContractsRun() {
+    (0, client_1.requireApiKey)();
+    const client = (0, client_1.createClient)();
+    return client.get('/v0/contracts/');
+}
+exports.contracts.command('list', {
+    description: 'List all tracked contracts for the project',
+    examples: [{ description: 'List all project contracts' }],
+    hint: 'Requires contracts:read scope on your API key.',
+    run() {
+        return listContractsRun();
+    },
+});
+function createContractRun(options) {
+    (0, client_1.requireApiKey)();
+    const client = (0, client_1.createClient)();
+    let parsedAbi;
+    try {
+        parsedAbi = JSON.parse(options.abi);
+    }
+    catch {
+        throw new Error('--abi must be a valid JSON array');
+    }
+    let parsedEvents;
+    try {
+        parsedEvents = JSON.parse(options.events);
+    }
+    catch {
+        throw new Error('--events must be valid JSON');
+    }
+    return client.post('/v0/contracts/', {
+        address: options.address,
+        chain: options.chain,
+        name: options.name,
+        abi: parsedAbi,
+        events: parsedEvents,
+    });
+}
+exports.contracts.command('create', {
+    description: 'Register a new smart contract to track',
+    options: incur_1.z.object({
+        address: incur_1.z.string().describe('Contract address (0x…)'),
+        chain: incur_1.z.coerce.number().describe('Chain ID (e.g. 1 for Ethereum, 137 for Polygon)'),
+        name: incur_1.z.string().describe('Human-readable contract name'),
+        abi: incur_1.z.string().describe('Contract ABI as a JSON string'),
+        events: incur_1.z.string().describe('Events configuration as a JSON string'),
+    }),
+    examples: [
+        {
+            options: {
+                address: '0x1234…',
+                chain: 1,
+                name: 'My Token',
+                abi: '[{"type":"event","name":"Transfer"}]',
+                events: '{"Transfer":true}',
+            },
+            description: 'Register an ERC-20 contract on Ethereum',
+        },
+    ],
+    hint: 'Requires contracts:write scope on your API key.',
+    run({ options }) {
+        return createContractRun(options);
+    },
+});
+function updateContractRun(chain, address, options) {
+    (0, client_1.requireApiKey)();
+    const client = (0, client_1.createClient)();
+    let parsedAbi;
+    try {
+        parsedAbi = JSON.parse(options.abi);
+    }
+    catch {
+        throw new Error('--abi must be a valid JSON array');
+    }
+    let parsedEvents;
+    try {
+        parsedEvents = JSON.parse(options.events);
+    }
+    catch {
+        throw new Error('--events must be valid JSON');
+    }
+    return client.put(`/v0/contracts/${encodeURIComponent(chain)}/${encodeURIComponent(address)}`, {
+        name: options.name,
+        abi: parsedAbi,
+        events: parsedEvents,
+    });
+}
+exports.contracts.command('update', {
+    description: 'Update a tracked contract',
+    args: incur_1.z.object({
+        chain: incur_1.z.string().describe('Chain ID'),
+        address: incur_1.z.string().describe('Contract address (0x…)'),
+    }),
+    options: incur_1.z.object({
+        name: incur_1.z.string().describe('Updated contract name'),
+        abi: incur_1.z.string().describe('Updated ABI as a JSON string'),
+        events: incur_1.z.string().describe('Updated events configuration as a JSON string'),
+    }),
+    examples: [
+        {
+            args: { chain: '1', address: '0x1234…' },
+            options: {
+                name: 'Renamed Token',
+                abi: '[{"type":"event","name":"Transfer"}]',
+                events: '{"Transfer":true}',
+            },
+            description: 'Update a contract',
+        },
+    ],
+    hint: 'Requires contracts:write scope on your API key.',
+    run({ args, options }) {
+        return updateContractRun(args.chain, args.address, options);
+    },
+});
+// ── Delete a contract ──
+function deleteContractRun(chain, address) {
+    (0, client_1.requireApiKey)();
+    const client = (0, client_1.createClient)();
+    return client.delete(`/v0/contracts/${encodeURIComponent(chain)}/${encodeURIComponent(address)}`);
+}
+exports.contracts.command('delete', {
+    description: 'Remove a tracked contract',
+    args: incur_1.z.object({
+        chain: incur_1.z.string().describe('Chain ID'),
+        address: incur_1.z.string().describe('Contract address (0x…)'),
+    }),
+    examples: [
+        {
+            args: { chain: '1', address: '0x1234…' },
+            description: 'Delete a contract',
+        },
+    ],
+    hint: 'Requires contracts:write scope on your API key.',
+    run({ args }) {
+        return deleteContractRun(args.chain, args.address);
+    },
+});

package/dist/commands/import.d.ts

@@ -0,0 +1,7 @@
+import { Cli } from 'incur';
+export declare const importCmd: Cli.Cli<{}, undefined, undefined>;
+export interface ImportWalletsOptions {
+    addresses: string;
+    writeKey: string;
+}
+export declare function importWalletsRun(options: ImportWalletsOptions): Promise<import("axios").AxiosResponse<any, any, {}>>;

package/dist/commands/import.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importCmd = void 0;
+exports.importWalletsRun = importWalletsRun;
+const incur_1 = require("incur");
+const client_1 = require("../lib/client");
+exports.importCmd = incur_1.Cli.create('import', {
+    description: 'Import commands — bulk import wallet addresses into your project',
+});
+function importWalletsRun(options) {
+    (0, client_1.requireApiKey)();
+    const client = (0, client_1.createClient)();
+    let parsedAddresses;
+    try {
+        parsedAddresses = JSON.parse(options.addresses);
+        if (!Array.isArray(parsedAddresses)) {
+            throw new Error('not an array');
+        }
+    }
+    catch {
+        throw new Error('--addresses must be a valid JSON array of wallet address strings');
+    }
+    return client.post('/v0/import/', {
+        addresses: parsedAddresses,
+        writeKey: options.writeKey,
+    });
+}
+exports.importCmd.command('wallets', {
+    description: 'Bulk import wallet addresses into the project',
+    options: incur_1.z.object({
+        addresses: incur_1.z
+            .string()
+            .describe('JSON array of wallet address strings to import'),
+        writeKey: incur_1.z.string().describe('Project write SDK key'),
+    }),
+    examples: [
+        {
+            options: {
+                addresses: '["0xabc…","0xdef…"]',
+                writeKey: 'write_key_xxx',
+            },
+            description: 'Import two wallet addresses',
+        },
+    ],
+    hint: 'Requires profiles:write scope. Only available on Scale and Enterprise plans.',
+    run({ options }) {
+        return importWalletsRun(options);
+    },
+});

package/dist/commands/profiles.d.ts

@@ -0,0 +1,14 @@
+import { Cli } from 'incur';
+export declare const profiles: Cli.Cli<{}, undefined, undefined>;
+export declare function getProfileRun(address: string, expand?: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
+export interface SearchProfilesOptions {
+    address?: string;
+    limit?: number;
+    offset?: number;
+    orderBy?: string;
+    orderDir?: string;
+    expand?: string;
+    conditions?: string;
+    logic?: 'and' | 'or';
+}
+export declare function searchProfilesRun(options: SearchProfilesOptions): Promise<import("axios").AxiosResponse<any, any, {}>>;

package/dist/commands/profiles.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profiles = void 0;
+exports.getProfileRun = getProfileRun;
+exports.searchProfilesRun = searchProfilesRun;
+const incur_1 = require("incur");
+const client_1 = require("../lib/client");
+exports.profiles = incur_1.Cli.create('profiles', {
+    description: 'Wallet profile commands',
+});
+function getProfileRun(address, expand) {
+    (0, client_1.requireApiKey)();
+    const client = (0, client_1.createClient)();
+    const params = {};
+    if (expand)
+        params.expand = expand;
+    return client.get(`/v0/profiles/${encodeURIComponent(address)}`, { params });
+}
+exports.profiles.command('get', {
+    description: 'Get a wallet profile by address',
+    args: incur_1.z.object({
+        address: incur_1.z.string().describe('Wallet address (0x... or ENS name)'),
+    }),
+    options: incur_1.z.object({
+        expand: incur_1.z
+            .string()
+            .optional()
+            .describe('Comma-separated list of fields to expand: apps,chains,tokens,labels'),
+    }),
+    examples: [
+        { args: { address: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045' }, description: 'Get a wallet profile' },
+        {
+            args: { address: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045' },
+            options: { expand: 'labels,chains' },
+            description: 'Get profile with expanded labels and chains',
+        },
+    ],
+    run({ args, options }) {
+        return getProfileRun(args.address, options.expand);
+    },
+});
+function searchProfilesRun(options) {
+    (0, client_1.requireApiKey)();
+    const client = (0, client_1.createClient)();
+    const params = {};
+    if (options.address)
+        params.address = options.address;
+    if (options.limit !== undefined)
+        params.limit = options.limit;
+    if (options.offset !== undefined)
+        params.offset = options.offset;
+    if (options.orderBy)
+        params.order_by = options.orderBy;
+    if (options.orderDir)
+        params.order_dir = options.orderDir;
+    if (options.expand)
+        params.expand = options.expand;
+    let body;
+    if (options.conditions) {
+        try {
+            const conditions = JSON.parse(options.conditions);
+            if (!Array.isArray(conditions))
+                throw new Error('not an array');
+            body = { conditions, logic: options.logic ?? 'and' };
+        }
+        catch {
+            throw new Error('--conditions must be valid JSON array of FilterCondition objects');
+        }
+    }
+    return client.request({ method: 'get', url: '/v0/profiles/', params, data: body });
+}
+exports.profiles.command('search', {
+    description: 'Search wallet profiles with optional filters',
+    options: incur_1.z.object({
+        address: incur_1.z.string().optional().describe('Filter by wallet address'),
+        limit: incur_1.z.coerce.number().optional().describe('Max results to return'),
+        offset: incur_1.z.coerce.number().optional().describe('Pagination offset'),
+        orderBy: incur_1.z
+            .enum([
+            'last_onchain',
+            'first_onchain',
+            'net_worth_usd',
+            'updated_at',
+            'tx_count',
+            'first_seen',
+            'last_seen',
+            'num_sessions',
+            'revenue',
+            'volume',
+            'points',
+        ])
+            .optional()
+            .describe('Field to sort by'),
+        orderDir: incur_1.z.enum(['asc', 'desc']).optional().describe('Sort direction'),
+        expand: incur_1.z.string().optional().describe('Comma-separated fields to expand'),
+        conditions: incur_1.z
+            .string()
+            .optional()
+            .describe('JSON array of FilterCondition objects for advanced filtering'),
+        logic: incur_1.z
+            .enum(['and', 'or'])
+            .optional()
+            .describe('Logic operator for combining conditions: "and" (default) or "or"'),
+    }),
+    examples: [
+        { options: { limit: 10 }, description: 'List first 10 profiles' },
+        {
+            options: { orderBy: 'net_worth_usd', orderDir: 'desc', limit: 5 },
+            description: 'Top 5 profiles by net worth',
+        },
+        {
+            options: {
+                conditions: '[{"field":"net_worth_usd","op":"gt","value":10000}]',
+                limit: 20,
+            },
+            description: 'Search profiles with net worth > 10000',
+        },
+        {
+            options: {
+                conditions: '[{"field":"net_worth_usd","op":"gt","value":10000},{"field":"tx_count","op":"gt","value":50}]',
+                logic: 'or',
+                limit: 20,
+            },
+            description: 'Search profiles matching either condition',
+        },
+    ],
+    run({ args: _args, options }) {
+        return searchProfilesRun(options);
+    },
+});

package/dist/commands/query.d.ts

@@ -0,0 +1 @@
+export declare function queryRunRun(sql: string): Promise<import("axios").AxiosResponse<any, any, {}>>;

package/dist/commands/query.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryRunRun = queryRunRun;
+const client_1 = require("../lib/client");
+function queryRunRun(sql) {
+    (0, client_1.requireApiKey)();
+    const client = (0, client_1.createClient)();
+    return client.post('/v0/query/', { query: sql });
+}

package/dist/commands/segments.d.ts

@@ -0,0 +1,9 @@
+import { Cli } from 'incur';
+export declare const segments: Cli.Cli<{}, undefined, undefined>;
+export declare function listSegmentsRun(): Promise<import("axios").AxiosResponse<any, any, {}>>;
+export interface CreateSegmentOptions {
+    title: string;
+    filterSets: string;
+}
+export declare function createSegmentRun(options: CreateSegmentOptions): Promise<import("axios").AxiosResponse<any, any, {}>>;
+export declare function deleteSegmentRun(segmentId: string): Promise<import("axios").AxiosResponse<any, any, {}>>;

package/dist/commands/segments.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.segments = void 0;
+exports.listSegmentsRun = listSegmentsRun;
+exports.createSegmentRun = createSegmentRun;
+exports.deleteSegmentRun = deleteSegmentRun;
+const incur_1 = require("incur");
+const client_1 = require("../lib/client");
+exports.segments = incur_1.Cli.create('segments', {
+    description: 'User segment commands — create, list, and delete audience segments',
+});
+// ── List segments ──
+function listSegmentsRun() {
+    (0, client_1.requireApiKey)();
+    const client = (0, client_1.createClient)();
+    return client.get('/v0/segments/');
+}
+exports.segments.command('list', {
+    description: 'List all user segments for the project',
+    examples: [{ description: 'List all project segments' }],
+    hint: 'Requires segments:read scope on your API key.',
+    run() {
+        return listSegmentsRun();
+    },
+});
+function createSegmentRun(options) {
+    (0, client_1.requireApiKey)();
+    const client = (0, client_1.createClient)();
+    let parsedFilterSets;
+    try {
+        parsedFilterSets = JSON.parse(options.filterSets);
+    }
+    catch {
+        throw new Error('--filterSets must be a valid JSON array');
+    }
+    return client.post('/v0/segments/', {
+        title: options.title,
+        filterSets: parsedFilterSets,
+    });
+}
+exports.segments.command('create', {
+    description: 'Create a new user segment',
+    options: incur_1.z.object({
+        title: incur_1.z.string().describe('Segment title'),
+        filterSets: incur_1.z
+            .string()
+            .describe('JSON array of filter set strings defining the segment'),
+    }),
+    examples: [
+        {
+            options: {
+                title: 'Whales',
+                filterSets: '["net_worth_usd > 100000"]',
+            },
+            description: 'Create a high-value segment',
+        },
+    ],
+    hint: 'Requires segments:write scope on your API key.',
+    run({ options }) {
+        return createSegmentRun(options);
+    },
+});
+// ── Delete a segment ──
+function deleteSegmentRun(segmentId) {
+    (0, client_1.requireApiKey)();
+    const client = (0, client_1.createClient)();
+    return client.delete(`/v0/segments/${encodeURIComponent(segmentId)}`);
+}
+exports.segments.command('delete', {
+    description: 'Delete a user segment',
+    args: incur_1.z.object({
+        segmentId: incur_1.z.string().describe('Segment ID to delete'),
+    }),
+    examples: [
+        { args: { segmentId: 'seg_abc123' }, description: 'Delete a segment' },
+    ],
+    hint: 'Requires segments:write scope on your API key.',
+    run({ args }) {
+        return deleteSegmentRun(args.segmentId);
+    },
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { Cli } from 'incur';
+declare const cli: Cli.Cli<{}, undefined, undefined>;
+export default cli;