@aisa-one/cli 0.0.1 → 0.1.1

package/README.md

@@ -0,0 +1,203 @@
+# @aisa-one/cli
+
+CLI for the [AISA](https://aisa.one) unified AI infrastructure platform. Access 70+ LLMs, web search, financial data, Twitter/X, and video generation APIs — all from one command line.
+
+## Install
+
+```bash
+npm install -g @aisa-one/cli
+```
+
+## Quick Start
+
+```bash
+# Authenticate
+aisa login --key sk-your-api-key
+
+# Chat with any LLM
+aisa chat "Explain quantum computing" --model claude-opus-4-6
+
+# Search the web
+aisa web-search "latest AI research"
+
+# Look up stock data
+aisa stock AAPL
+
+# Post a tweet
+aisa tweet "Hello from AISA CLI!"
+
+# Generate a video
+aisa video create "A cat playing piano" --wait
+```
+
+Get your API key at [aisa.one/dashboard](https://aisa.one/dashboard). New accounts receive $5 in free credits.
+
+## Commands
+
+### Authentication
+
+```bash
+aisa login --key <key>    # Store API key (also reads AISA_API_KEY env var)
+aisa logout               # Remove stored key
+aisa whoami               # Show auth status
+```
+
+### LLM Gateway
+
+Chat with 70+ models (GPT, Claude, Gemini, Qwen, Deepseek, Grok) through a single OpenAI-compatible endpoint.
+
+```bash
+aisa chat "your message" --model gpt-4.1
+aisa chat "explain this" --model claude-opus-4-6 --stream
+aisa chat "respond in JSON" --model gemini-2.5-pro --json
+echo "summarize this" | aisa chat                        # pipe support
+
+aisa models                          # list all models
+aisa models --provider anthropic     # filter by provider
+aisa models show gpt-4.1             # model details + pricing
+```
+
+### API Discovery & Execution
+
+```bash
+aisa api list                                # list all API endpoints
+aisa api list --category finance             # filter by category
+aisa api search "email finder"               # natural language search
+aisa api show finance /stock/price           # endpoint details + params
+aisa api code finance /stock/price --lang python  # generate code snippet
+
+# Execute any API
+aisa run finance /stock/price -q "symbol=AAPL"
+aisa run tavily /search -d '{"query": "AI news"}'
+aisa run twitter /tweet/advanced-search -q "query=AI agents" --raw
+```
+
+### Web Search
+
+```bash
+aisa web-search "query"                     # smart search (default)
+aisa web-search "query" --type full         # full-text search
+aisa web-search "query" --type youtube      # YouTube search
+aisa web-search "query" --type tavily       # Tavily deep search
+aisa scholar "transformer architecture"     # academic papers
+```
+
+### Finance
+
+```bash
+aisa stock AAPL                     # stock price
+aisa stock MSFT --field earnings    # earnings data
+aisa stock TSLA --field filings     # SEC filings
+aisa stock NVDA --field insider     # insider trades
+aisa crypto BTC                     # crypto price
+aisa crypto ETH --period 30d       # historical
+aisa screener --sector Technology   # stock screener
+```
+
+### Twitter/X
+
+```bash
+aisa tweet "Hello world!"                   # post a tweet
+aisa tweet "Reply" --reply-to 123456        # reply
+aisa twitter search "AI agents" --limit 20  # search tweets
+aisa twitter user elonmusk                  # user profile
+aisa twitter trends                         # trending topics
+```
+
+### Video Generation
+
+```bash
+aisa video create "A sunset timelapse"           # create task
+aisa video create "Dancing robot" --wait         # wait for result
+aisa video status <task-id>                      # check status
+```
+
+### Account
+
+```bash
+aisa balance                # credit balance
+aisa usage --limit 20       # usage history
+aisa usage --days 7         # last 7 days
+```
+
+## Skills
+
+Skills are markdown files that teach AI coding agents (Claude Code, Cursor, Copilot, etc.) how to use AISA APIs.
+
+### Browse & Install
+
+```bash
+aisa skills list                              # browse skills
+aisa skills search "financial analysis"       # search
+aisa skills show aisa-team/finance-analyst    # details
+aisa skills add aisa-team/finance-analyst     # install to all agents
+aisa skills add aisa-team/llm-assistant --agent claude  # specific agent
+aisa skills remove aisa-team/finance-analyst  # uninstall
+```
+
+Skills install to agent directories automatically:
+
+| Agent | Directory |
+|-------|-----------|
+| Claude Code | `~/.claude/skills/` |
+| Cursor | `~/.cursor/skills/` |
+| GitHub Copilot | `~/.github/skills/` |
+| Windsurf | `~/.codeium/windsurf/skills/` |
+| Codex | `~/.agents/skills/` |
+| Gemini | `~/.gemini/skills/` |
+| OpenClaw | `~/.openclaw/skills/` |
+
+### Create & Publish
+
+```bash
+aisa skills init my-skill                          # create from default template
+aisa skills init my-skill --template finance       # finance template
+aisa skills init my-skill --template llm           # LLM template
+aisa skills submit ./my-skill                      # submit to AISA
+aisa skills push owner/my-skill                    # push updates
+aisa skills request-verification owner/my-skill    # request review
+```
+
+Available templates: `default`, `llm`, `search`, `finance`, `twitter`, `video`
+
+## MCP Server
+
+Auto-configure AISA's MCP server for your AI agents:
+
+```bash
+aisa mcp setup                          # configure all detected agents
+aisa mcp setup --agent cursor           # Cursor only
+aisa mcp setup --agent claude-desktop   # Claude Desktop only
+aisa mcp status                         # check configuration
+```
+
+## Configuration
+
+```bash
+aisa config set defaultModel claude-opus-4-6   # change default model
+aisa config get defaultModel                    # read a value
+aisa config list                                # show all settings
+aisa config reset                               # reset to defaults
+```
+
+Settings:
+- `defaultModel` — default model for `aisa chat` (default: `gpt-4.1`)
+- `baseUrl` — API base URL (default: `https://api.aisa.one`)
+- `outputFormat` — output format: `text` or `json`
+
+Environment variable `AISA_API_KEY` takes precedence over stored key.
+
+## Development
+
+```bash
+git clone https://github.com/AIsa-team/cli.git
+cd cli
+npm install
+npm run build       # compile TypeScript
+npm run dev         # watch mode
+npm test            # run tests
+```
+
+## License
+
+MIT

package/dist/api.d.ts

@@ -0,0 +1,11 @@
+import { type Response } from "node-fetch";
+import type { ApiResponse } from "./types.js";
+export interface RequestOptions {
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    query?: Record<string, string>;
+    body?: unknown;
+    stream?: boolean;
+    headers?: Record<string, string>;
+}
+export declare function apiRequest<T = unknown>(apiKey: string, endpoint: string, options?: RequestOptions): Promise<ApiResponse<T>>;
+export declare function apiRequestRaw(apiKey: string, endpoint: string, options?: RequestOptions): Promise<Response>;

package/dist/api.js

@@ -0,0 +1,61 @@
+import fetch from "node-fetch";
+import { CLI_BASE_URL } from "./constants.js";
+import { getConfig } from "./config.js";
+function getBaseUrl() {
+    const custom = getConfig("baseUrl");
+    return custom || CLI_BASE_URL;
+}
+export async function apiRequest(apiKey, endpoint, options = {}) {
+    const { method = "GET", query, body, headers: extraHeaders } = options;
+    const baseUrl = getBaseUrl();
+    let url = `${baseUrl}/${endpoint}`;
+    if (query) {
+        const params = new URLSearchParams(query);
+        url += `?${params.toString()}`;
+    }
+    const headers = {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        "x-aisa-source": "cli",
+        ...extraHeaders,
+    };
+    const res = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        let errorMsg;
+        try {
+            const json = JSON.parse(text);
+            errorMsg = json.error?.message || json.error || json.message || text;
+        }
+        catch {
+            errorMsg = text;
+        }
+        return { success: false, error: `${res.status}: ${errorMsg}` };
+    }
+    const data = (await res.json());
+    return { success: true, data };
+}
+export async function apiRequestRaw(apiKey, endpoint, options = {}) {
+    const { method = "GET", query, body, headers: extraHeaders } = options;
+    const baseUrl = getBaseUrl();
+    let url = `${baseUrl}/${endpoint}`;
+    if (query) {
+        const params = new URLSearchParams(query);
+        url += `?${params.toString()}`;
+    }
+    const headers = {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        "x-aisa-source": "cli",
+        ...extraHeaders,
+    };
+    return fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+    });
+}

package/dist/commands/account.d.ts

@@ -0,0 +1,5 @@
+export declare function balanceAction(): Promise<void>;
+export declare function usageAction(options: {
+    limit?: string;
+    days?: string;
+}): Promise<void>;

package/dist/commands/account.js

@@ -0,0 +1,47 @@
+import ora from "ora";
+import chalk from "chalk";
+import { requireApiKey } from "../config.js";
+import { apiRequest } from "../api.js";
+import { error, table } from "../utils/display.js";
+export async function balanceAction() {
+    const key = requireApiKey();
+    const spinner = ora("Fetching balance...").start();
+    const res = await apiRequest(key, "credits/balance");
+    if (!res.success || !res.data) {
+        spinner.fail("Failed to fetch balance");
+        error(res.error || "Unknown error");
+        return;
+    }
+    spinner.stop();
+    console.log(`  Balance: ${chalk.green("$" + res.data.balance.toFixed(2))} ${res.data.currency}`);
+    console.log(chalk.gray("  Add credits at https://aisa.one/dashboard/wallet"));
+}
+export async function usageAction(options) {
+    const key = requireApiKey();
+    const spinner = ora("Fetching usage...").start();
+    const query = {};
+    if (options.limit)
+        query.limit = options.limit;
+    if (options.days)
+        query.days = options.days;
+    const res = await apiRequest(key, "credits/usage", { query });
+    if (!res.success || !res.data) {
+        spinner.fail("Failed to fetch usage");
+        error(res.error || "Unknown error");
+        return;
+    }
+    spinner.stop();
+    const { records } = res.data;
+    if (records.length === 0) {
+        console.log("  No usage records found.");
+        return;
+    }
+    const rows = records.map((r) => [
+        new Date(r.timestamp).toLocaleDateString(),
+        r.api,
+        r.endpoint,
+        `$${r.cost.toFixed(4)}`,
+        r.status,
+    ]);
+    console.log(table(["Date", "API", "Endpoint", "Cost", "Status"], rows));
+}

package/dist/commands/api.d.ts

@@ -0,0 +1,10 @@
+export declare function apiListAction(options: {
+    category?: string;
+}): Promise<void>;
+export declare function apiSearchAction(query: string, options: {
+    limit?: string;
+}): Promise<void>;
+export declare function apiShowAction(slug: string, path?: string): Promise<void>;
+export declare function apiCodeAction(slug: string, path: string, options: {
+    lang?: string;
+}): Promise<void>;

package/dist/commands/api.js

@@ -0,0 +1,116 @@
+import ora from "ora";
+import chalk from "chalk";
+import { requireApiKey } from "../config.js";
+import { apiRequest } from "../api.js";
+import { error, badge, table, hint, truncate } from "../utils/display.js";
+export async function apiListAction(options) {
+    const key = requireApiKey();
+    const spinner = ora("Listing APIs...").start();
+    const query = {};
+    if (options.category)
+        query.category = options.category;
+    const res = await apiRequest(key, "cli/apis", { query });
+    if (!res.success || !res.data) {
+        spinner.fail("Failed to list APIs");
+        error(res.error || "Unknown error");
+        return;
+    }
+    spinner.stop();
+    const { apis } = res.data;
+    if (apis.length === 0) {
+        console.log("  No APIs found.");
+        return;
+    }
+    for (const api of apis) {
+        console.log(`\n  ${chalk.cyan.bold(api.name)} ${chalk.gray(api.slug)} ${badge(api.category)}`);
+        console.log(`  ${chalk.gray(api.description)}`);
+        const shown = api.endpoints.slice(0, 3);
+        for (const ep of shown) {
+            console.log(`    ${chalk.yellow(ep.method.padEnd(6))} ${ep.path} ${chalk.gray("- " + truncate(ep.description, 50))}`);
+        }
+        if (api.endpoints.length > 3) {
+            hint(`+${api.endpoints.length - 3} more endpoints`);
+        }
+    }
+    console.log(chalk.gray("\n  Run 'aisa api show <slug>' for endpoint details"));
+}
+export async function apiSearchAction(query, options) {
+    const key = requireApiKey();
+    const spinner = ora(`Searching "${query}"...`).start();
+    const res = await apiRequest(key, "cli/apis/search", {
+        method: "POST",
+        body: { query, limit: parseInt(options.limit || "10") },
+    });
+    if (!res.success || !res.data) {
+        spinner.fail("Search failed");
+        error(res.error || "Unknown error");
+        return;
+    }
+    spinner.stop();
+    const { apis } = res.data;
+    if (apis.length === 0) {
+        console.log(`  No APIs found for "${query}".`);
+        return;
+    }
+    for (const api of apis) {
+        console.log(`\n  ${chalk.cyan.bold(api.name)} ${chalk.gray(api.slug)} ${badge(api.category)}`);
+        console.log(`  ${chalk.gray(api.description)}`);
+        for (const ep of api.endpoints.slice(0, 2)) {
+            console.log(`    ${chalk.yellow(ep.method.padEnd(6))} ${ep.path}`);
+        }
+    }
+    console.log(chalk.gray("\n  Run 'aisa run <slug> <path>' to execute"));
+}
+export async function apiShowAction(slug, path) {
+    const key = requireApiKey();
+    const spinner = ora(`Loading ${slug}${path ? " " + path : ""}...`).start();
+    const endpoint = path ? `cli/apis/${slug}${path}` : `cli/apis/${slug}`;
+    const res = await apiRequest(key, endpoint);
+    if (!res.success || !res.data) {
+        spinner.fail("Failed to load API details");
+        error(res.error || "Unknown error");
+        return;
+    }
+    spinner.stop();
+    const data = res.data;
+    if ("endpoints" in data) {
+        // ApiGroup
+        console.log(`\n  ${chalk.cyan.bold(data.name)} ${badge(data.category)}`);
+        console.log(`  ${data.description}\n`);
+        for (const ep of data.endpoints) {
+            console.log(`  ${chalk.yellow(ep.method.padEnd(6))} ${ep.path}`);
+            console.log(`  ${chalk.gray(ep.description)}`);
+        }
+    }
+    else {
+        // ApiEndpoint with parameters
+        console.log(`\n  ${chalk.yellow(data.method)} ${data.path}`);
+        console.log(`  ${data.description}\n`);
+        if (data.parameters && data.parameters.length > 0) {
+            const rows = data.parameters.map((p) => [
+                p.name,
+                p.type,
+                p.required ? chalk.red("required") : "optional",
+                truncate(p.description, 40),
+            ]);
+            console.log(table(["Name", "Type", "Required", "Description"], rows));
+        }
+        console.log(chalk.gray(`\n  Example: aisa run ${slug} ${data.path} -q "param=value"`));
+    }
+}
+export async function apiCodeAction(slug, path, options) {
+    const key = requireApiKey();
+    const lang = options.lang || "typescript";
+    const spinner = ora(`Generating ${lang} code...`).start();
+    const res = await apiRequest(key, "cli/apis/code", {
+        method: "POST",
+        body: { slug, path, language: lang },
+    });
+    if (!res.success || !res.data) {
+        spinner.fail("Failed to generate code");
+        error(res.error || "Unknown error");
+        return;
+    }
+    spinner.stop();
+    console.log(`\n${res.data.code}`);
+}

package/dist/commands/auth.d.ts

@@ -0,0 +1,5 @@
+export declare function loginAction(options: {
+    key?: string;
+}): void;
+export declare function logoutAction(): void;
+export declare function whoamiAction(): void;

package/dist/commands/auth.js

@@ -0,0 +1,29 @@
+import chalk from "chalk";
+import { setApiKey, clearApiKey, getApiKey, getKeySource, maskKey } from "../config.js";
+import { success, error, info } from "../utils/display.js";
+import { ENV_VAR_NAME } from "../constants.js";
+export function loginAction(options) {
+    const key = options.key || process.env[ENV_VAR_NAME];
+    if (!key) {
+        error(`Provide a key with --key or set ${ENV_VAR_NAME}`);
+        process.exit(1);
+    }
+    setApiKey(key);
+    success(`Authenticated: ${maskKey(key)}`);
+    console.log(chalk.gray("  Get your API key at https://aisa.one/dashboard"));
+}
+export function logoutAction() {
+    clearApiKey();
+    success("Logged out. API key removed.");
+}
+export function whoamiAction() {
+    const key = getApiKey();
+    const source = getKeySource();
+    if (!key) {
+        info("Not authenticated.");
+        console.log(chalk.gray(`  Run "aisa login --key <key>" or set ${ENV_VAR_NAME}`));
+        return;
+    }
+    console.log(`  Key:    ${maskKey(key)}`);
+    console.log(`  Source: ${source === "env" ? `${ENV_VAR_NAME} env var` : "stored config"}`);
+}

package/dist/commands/chat.d.ts

@@ -0,0 +1,8 @@
+export declare function chatAction(message: string | undefined, options: {
+    model?: string;
+    system?: string;
+    stream?: boolean;
+    json?: boolean;
+    maxTokens?: string;
+    temperature?: string;
+}): Promise<void>;

package/dist/commands/chat.js

@@ -0,0 +1,78 @@
+import ora from "ora";
+import chalk from "chalk";
+import { requireApiKey, getConfig } from "../config.js";
+import { apiRequest, apiRequestRaw } from "../api.js";
+import { error } from "../utils/display.js";
+import { handleSSEStream } from "../utils/streaming.js";
+export async function chatAction(message, options) {
+    const key = requireApiKey();
+    // Read from stdin if no message provided
+    let text = message;
+    if (!text) {
+        if (process.stdin.isTTY) {
+            error("Provide a message or pipe input: echo 'hello' | aisa chat");
+            process.exit(1);
+        }
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        text = Buffer.concat(chunks).toString("utf-8").trim();
+    }
+    if (!text) {
+        error("Empty message");
+        process.exit(1);
+    }
+    const model = options.model || getConfig("defaultModel") || "gpt-4.1";
+    const stream = options.stream !== false; // default true
+    const messages = [];
+    if (options.system) {
+        messages.push({ role: "system", content: options.system });
+    }
+    messages.push({ role: "user", content: text });
+    const body = { model, messages, stream };
+    if (options.maxTokens)
+        body.max_tokens = parseInt(options.maxTokens);
+    if (options.temperature)
+        body.temperature = parseFloat(options.temperature);
+    if (stream) {
+        const res = await apiRequestRaw(key, "chat/completions", {
+            method: "POST",
+            body,
+            headers: { Accept: "text/event-stream" },
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            error(`${res.status}: ${text}`);
+            return;
+        }
+        await handleSSEStream(res, (token) => process.stdout.write(token), (usage) => {
+            console.log();
+            if (usage) {
+                console.log(chalk.gray(`  ${model} · ${usage.prompt_tokens} in / ${usage.completion_tokens} out`));
+            }
+        });
+    }
+    else {
+        const spinner = ora(`${model}...`).start();
+        const res = await apiRequest(key, "chat/completions", {
+            method: "POST",
+            body,
+        });
+        if (!res.success || !res.data) {
+            spinner.fail("Chat failed");
+            error(res.error || "Unknown error");
+            return;
+        }
+        spinner.stop();
+        if (options.json) {
+            console.log(JSON.stringify(res.data, null, 2));
+        }
+        else {
+            console.log(res.data.choices[0].message.content);
+            if (res.data.usage) {
+                console.log(chalk.gray(`\n  ${model} · ${res.data.usage.prompt_tokens} in / ${res.data.usage.completion_tokens} out`));
+            }
+        }
+    }
+}

package/dist/commands/configCmd.d.ts

@@ -0,0 +1,4 @@
+export declare function configSetAction(key: string, value: string): void;
+export declare function configGetAction(key: string): void;
+export declare function configListAction(): void;
+export declare function configResetAction(): void;

package/dist/commands/configCmd.js

@@ -0,0 +1,36 @@
+import chalk from "chalk";
+import { getConfig, setConfig, listConfig, resetConfig } from "../config.js";
+import { success, info } from "../utils/display.js";
+const VALID_KEYS = ["defaultModel", "baseUrl", "outputFormat"];
+export function configSetAction(key, value) {
+    if (!VALID_KEYS.includes(key)) {
+        console.error(`Unknown config key: ${key}`);
+        console.error(`Valid keys: ${VALID_KEYS.join(", ")}`);
+        process.exit(1);
+    }
+    setConfig(key, value);
+    success(`${key} = ${value}`);
+}
+export function configGetAction(key) {
+    const value = getConfig(key);
+    if (value === undefined) {
+        info(`${key} is not set.`);
+    }
+    else {
+        console.log(`  ${key} = ${value}`);
+    }
+}
+export function configListAction() {
+    const all = listConfig();
+    const display = { ...all };
+    if (display.apiKey) {
+        display.apiKey = "****";
+    }
+    for (const [k, v] of Object.entries(display)) {
+        console.log(`  ${chalk.cyan(k)} = ${v}`);
+    }
+}
+export function configResetAction() {
+    resetConfig();
+    success("Config reset to defaults.");
+}

package/dist/commands/finance.d.ts

@@ -0,0 +1,13 @@
+export declare function stockAction(symbol: string, options: {
+    field?: string;
+    raw?: boolean;
+}): Promise<void>;
+export declare function cryptoAction(symbol: string, options: {
+    period?: string;
+    raw?: boolean;
+}): Promise<void>;
+export declare function screenerAction(options: {
+    sector?: string;
+    limit?: string;
+    raw?: boolean;
+}): Promise<void>;