@aisa-one/cli 0.1.0 → 0.1.2

package/dist/api.d.ts

@@ -6,6 +6,8 @@ export interface RequestOptions {
     body?: unknown;
     stream?: boolean;
     headers?: Record<string, string>;
+    /** Use domain API base URL (/apis/v1) instead of LLM base (/v1) */
+    domain?: boolean;
 }
 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

@@ -1,13 +1,13 @@
 import fetch from "node-fetch";
-import { CLI_BASE_URL } from "./constants.js";
+import { CLI_BASE_URL, APIS_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();
+    const { method = "GET", query, body, headers: extraHeaders, domain } = options;
+    const baseUrl = domain ? APIS_BASE_URL : getBaseUrl();
     let url = `${baseUrl}/${endpoint}`;
     if (query) {
         const params = new URLSearchParams(query);
@@ -40,8 +40,8 @@ export async function apiRequest(apiKey, endpoint, options = {}) {
     return { success: true, data };
 }
 export async function apiRequestRaw(apiKey, endpoint, options = {}) {
-    const { method = "GET", query, body, headers: extraHeaders } = options;
-    const baseUrl = getBaseUrl();
+    const { method = "GET", query, body, headers: extraHeaders, domain } = options;
+    const baseUrl = domain ? APIS_BASE_URL : getBaseUrl();
     let url = `${baseUrl}/${endpoint}`;
     if (query) {
         const params = new URLSearchParams(query);

package/dist/commands/finance.js

@@ -3,12 +3,14 @@ import { requireApiKey } from "../config.js";
 import { apiRequest } from "../api.js";
 import { error, formatJson } from "../utils/display.js";
 const FIELD_ENDPOINTS = {
-    price: "stock/price",
-    earnings: "analyst-estimates",
-    financials: "financial-statements",
-    filings: "filings",
-    insider: "insider-trades",
-    institutional: "institutional-ownership",
+    price: "financial/prices",
+    earnings: "financial/earnings/press-releases",
+    financials: "financial/financials",
+    filings: "financial/filings",
+    insider: "financial/insider-trades",
+    institutional: "financial/institutional-ownership",
+    metrics: "financial/financial-metrics/snapshot",
+    news: "financial/news",
 };
 export async function stockAction(symbol, options) {
     const key = requireApiKey();
@@ -19,8 +21,21 @@ export async function stockAction(symbol, options) {
         return;
     }
     const spinner = ora(`Fetching ${field} for ${symbol.toUpperCase()}...`).start();
+    const query = { ticker: symbol.toUpperCase() };
+    // Price endpoint needs additional params for sensible defaults
+    if (field === "price") {
+        const end = new Date();
+        const start = new Date();
+        start.setDate(start.getDate() - 30);
+        query.interval = "day";
+        query.interval_multiplier = "1";
+        query.start_date = start.toISOString().split("T")[0];
+        query.end_date = end.toISOString().split("T")[0];
+        query.limit = "30";
+    }
     const res = await apiRequest(key, endpoint, {
-        query: { symbol: symbol.toUpperCase() },
+        query,
+        domain: true,
     });
     if (!res.success) {
         spinner.fail(`Failed to fetch ${field}`);
@@ -38,13 +53,25 @@ export async function stockAction(symbol, options) {
 export async function cryptoAction(symbol, options) {
     const key = requireApiKey();
     const spinner = ora(`Fetching ${symbol.toUpperCase()}...`).start();
-    const query = { symbol: symbol.toUpperCase() };
-    if (options.period)
-        query.period = options.period;
-    const endpoint = options.period && options.period !== "current"
-        ? "crypto/price"
-        : "crypto/price/snapshot";
-    const res = await apiRequest(key, endpoint, { query });
+    // Format ticker: BTC → BTC-USD
+    const ticker = symbol.toUpperCase().includes("-") ? symbol.toUpperCase() : `${symbol.toUpperCase()}-USD`;
+    let endpoint;
+    const query = { ticker };
+    if (!options.period || options.period === "current") {
+        endpoint = "financial/crypto/prices/snapshot";
+    }
+    else {
+        endpoint = "financial/crypto/prices";
+        const end = new Date();
+        const start = new Date();
+        const periodMap = { "1d": 1, "7d": 7, "30d": 30, "1y": 365 };
+        start.setDate(start.getDate() - (periodMap[options.period] || 30));
+        query.interval = "day";
+        query.interval_multiplier = "1";
+        query.start_date = start.toISOString().split("T")[0];
+        query.end_date = end.toISOString().split("T")[0];
+    }
+    const res = await apiRequest(key, endpoint, { query, domain: true });
     if (!res.success) {
         spinner.fail("Failed to fetch crypto price");
         error(res.error || "Unknown error");
@@ -61,14 +88,22 @@ export async function cryptoAction(symbol, options) {
 export async function screenerAction(options) {
     const key = requireApiKey();
     const spinner = ora("Running stock screener...").start();
-    const body = {};
-    if (options.sector)
-        body.sector = options.sector;
+    const body = {
+        filters: [],
+    };
+    if (options.sector) {
+        body.filters.push({
+            field: "sector",
+            operator: "eq",
+            value: options.sector,
+        });
+    }
     if (options.limit)
         body.limit = parseInt(options.limit);
-    const res = await apiRequest(key, "search/financials", {
+    const res = await apiRequest(key, "financial/financials/search", {
         method: "POST",
         body,
+        domain: true,
     });
     if (!res.success) {
         spinner.fail("Screener failed");

package/dist/commands/models.js

@@ -6,25 +6,27 @@ import { error, badge } from "../utils/display.js";
 export async function modelsListAction(options) {
     const key = requireApiKey();
     const spinner = ora("Fetching models...").start();
-    const query = {};
-    if (options.provider)
-        query.provider = options.provider;
-    const res = await apiRequest(key, "models", { query });
+    const res = await apiRequest(key, "models");
     if (!res.success || !res.data) {
         spinner.fail("Failed to fetch models");
         error(res.error || "Unknown error");
         return;
     }
     spinner.stop();
-    const models = res.data.data;
+    let models = res.data.data;
+    // Filter by provider if specified
+    if (options.provider) {
+        const filter = options.provider.toLowerCase();
+        models = models.filter((m) => m.owned_by?.toLowerCase().includes(filter));
+    }
     if (models.length === 0) {
         console.log("  No models found.");
         return;
     }
-    // Group by provider
+    // Group by owned_by (provider)
     const grouped = {};
     for (const m of models) {
-        const p = m.provider || "other";
+        const p = m.owned_by || "other";
         if (!grouped[p])
             grouped[p] = [];
         grouped[p].push(m);
@@ -49,17 +51,13 @@ export async function modelsShowAction(modelId) {
     }
     spinner.stop();
     const m = res.data;
-    console.log(`\n  ${chalk.cyan.bold(m.name)} ${badge(m.provider)}`);
-    console.log(`  ID: ${m.id}`);
-    if (m.contextWindow)
-        console.log(`  Context: ${(m.contextWindow / 1000).toFixed(0)}k tokens`);
-    if (m.maxTokens)
-        console.log(`  Max output: ${(m.maxTokens / 1000).toFixed(0)}k tokens`);
-    if (m.pricing) {
-        console.log(`  Pricing: $${m.pricing.input}/M input, $${m.pricing.output}/M output`);
-    }
-    if (m.capabilities?.length) {
-        console.log(`  Capabilities: ${m.capabilities.join(", ")}`);
+    console.log(`\n  ${chalk.cyan.bold(m.id)} ${badge(m.owned_by)}`);
+    if (m.owned_by)
+        console.log(`  Provider: ${m.owned_by}`);
+    if (m.created)
+        console.log(`  Created: ${new Date(m.created * 1000).toLocaleDateString()}`);
+    if (m.supported_endpoint_types?.length) {
+        console.log(`  Endpoints: ${m.supported_endpoint_types.join(", ")}`);
     }
     console.log(chalk.gray(`\n  Use: aisa chat "message" --model ${m.id}`));
 }

package/dist/commands/run.js

@@ -32,6 +32,9 @@ export async function runAction(slug, path, options) {
     // Detect method
     const method = (options.method || (body ? "POST" : "GET")).toUpperCase();
     const endpoint = `${slug}${path}`;
+    // Auto-detect domain API vs LLM API based on slug
+    const domainSlugs = ["financial", "search", "youtube", "scholar", "tavily", "querit", "twitter", "services", "crypto"];
+    const isDomain = domainSlugs.some((s) => slug.startsWith(s));
     // Streaming mode
     if (options.stream) {
         const res = await apiRequestRaw(key, endpoint, {
@@ -39,6 +42,7 @@ export async function runAction(slug, path, options) {
             query: Object.keys(query).length > 0 ? query : undefined,
             body,
             headers: { Accept: "text/event-stream" },
+            domain: isDomain,
         });
         if (!res.ok) {
             const text = await res.text();
@@ -54,6 +58,7 @@ export async function runAction(slug, path, options) {
         method,
         query: Object.keys(query).length > 0 ? query : undefined,
         body,
+        domain: isDomain,
     });
     if (!res.success) {
         spinner.fail("API call failed");

package/dist/commands/search.js

@@ -1,4 +1,5 @@
 import ora from "ora";
+import chalk from "chalk";
 import { requireApiKey } from "../config.js";
 import { apiRequest } from "../api.js";
 import { error, formatJson } from "../utils/display.js";
@@ -7,11 +8,11 @@ export async function webSearchAction(query, options) {
     const type = options.type || "smart";
     const spinner = ora(`Searching (${type})...`).start();
     const endpointMap = {
-        smart: { endpoint: "search/smart", method: "GET" },
-        full: { endpoint: "search/full", method: "GET" },
-        youtube: { endpoint: "youtube/search", method: "GET" },
-        scholar: { endpoint: "scholar/search", method: "POST" },
-        tavily: { endpoint: "tavily/search", method: "POST" },
+        smart: { endpoint: "search/smart", method: "GET", paramStyle: "query" },
+        full: { endpoint: "search/full", method: "GET", paramStyle: "query" },
+        youtube: { endpoint: "youtube/search", method: "GET", paramStyle: "query" },
+        scholar: { endpoint: "scholar/search/scholar", method: "POST", paramStyle: "query" },
+        tavily: { endpoint: "tavily/search", method: "POST", paramStyle: "body" },
     };
     const config = endpointMap[type];
     if (!config) {
@@ -19,12 +20,27 @@ export async function webSearchAction(query, options) {
         error("Valid types: smart, full, youtube, scholar, tavily");
         return;
     }
-    const res = await apiRequest(key, config.endpoint, {
+    // Build request options
+    const reqOpts = {
         method: config.method,
-        ...(config.method === "GET"
-            ? { query: { query, ...(options.limit ? { limit: options.limit } : {}) } }
-            : { body: { query, limit: parseInt(options.limit || "10") } }),
-    });
+        domain: true,
+    };
+    if (config.paramStyle === "query") {
+        // GET-style search endpoints use 'q' for smart/full/youtube, 'query' for scholar
+        const qParam = type === "scholar" ? "query" : "q";
+        reqOpts.query = { [qParam]: query };
+        if (options.limit) {
+            reqOpts.query[type === "scholar" ? "max_num_results" : "count"] = options.limit;
+        }
+    }
+    else {
+        // Tavily uses POST body
+        reqOpts.body = {
+            query,
+            ...(options.limit ? { max_results: parseInt(options.limit) } : {}),
+        };
+    }
+    const res = await apiRequest(key, config.endpoint, reqOpts);
     if (!res.success) {
         spinner.fail("Search failed");
         error(res.error || "Unknown error");
@@ -35,6 +51,23 @@ export async function webSearchAction(query, options) {
         console.log(JSON.stringify(res.data));
     }
     else {
+        // Format search results nicely
+        const data = res.data;
+        // Smart/Full search format
+        if (data?.webPages && typeof data.webPages === "object") {
+            const pages = data.webPages;
+            if (pages.value) {
+                for (const result of pages.value) {
+                    console.log(`\n  ${chalk.cyan.bold(result.name)}`);
+                    console.log(`  ${chalk.gray(result.url)}`);
+                    if (result.snippet)
+                        console.log(`  ${result.snippet}`);
+                }
+                console.log(chalk.gray(`\n  ${pages.value.length} results`));
+                return;
+            }
+        }
+        // Fallback to generic JSON display
         console.log(formatJson(res.data));
     }
 }

package/dist/commands/twitter.js

@@ -6,16 +6,24 @@ import { error, formatJson } from "../utils/display.js";
 export async function tweetAction(text, options) {
     const key = requireApiKey();
     const spinner = ora("Posting tweet...").start();
-    const body = { text };
+    const body = { tweet_text: text };
     if (options.replyTo)
-        body.reply_to = options.replyTo;
-    const res = await apiRequest(key, "twitter/create-tweet-v2", {
+        body.reply_to_tweet_id = options.replyTo;
+    // Note: create_tweet_v2 requires login_cookies and proxy
+    // This will fail without those - provide a helpful message
+    const res = await apiRequest(key, "twitter/create_tweet_v2", {
         method: "POST",
         body,
+        domain: true,
     });
     if (!res.success) {
         spinner.fail("Failed to post tweet");
-        error(res.error || "Unknown error");
+        if (res.error?.includes("login_cookies")) {
+            error("Tweet creation requires Twitter login cookies. See: https://docs.aisa.one");
+        }
+        else {
+            error(res.error || "Unknown error");
+        }
         return;
     }
     spinner.stop();
@@ -30,10 +38,13 @@ export async function tweetAction(text, options) {
 export async function twitterSearchAction(query, options) {
     const key = requireApiKey();
     const spinner = ora(`Searching tweets: "${query}"...`).start();
-    const q = { query };
+    const q = { query, queryType: "Latest" };
     if (options.limit)
-        q.limit = options.limit;
-    const res = await apiRequest(key, "twitter/tweet/advanced-search", { query: q });
+        q.cursor = "";
+    const res = await apiRequest(key, "twitter/tweet/advanced_search", {
+        query: q,
+        domain: true,
+    });
     if (!res.success) {
         spinner.fail("Twitter search failed");
         error(res.error || "Unknown error");
@@ -51,7 +62,8 @@ export async function twitterUserAction(username, options) {
     const key = requireApiKey();
     const spinner = ora(`Fetching @${username}...`).start();
     const res = await apiRequest(key, "twitter/user/info", {
-        query: { username },
+        query: { userName: username },
+        domain: true,
     });
     if (!res.success) {
         spinner.fail("Failed to fetch user");
@@ -63,13 +75,31 @@ export async function twitterUserAction(username, options) {
         console.log(JSON.stringify(res.data));
     }
     else {
-        console.log(formatJson(res.data));
+        const data = res.data;
+        const user = data?.data;
+        if (user) {
+            console.log(`\n  ${chalk.cyan.bold(user.name)} ${chalk.gray(`@${user.userName}`)}`);
+            if (user.description)
+                console.log(`  ${user.description}`);
+            console.log(`  ${chalk.white(String(user.followers))} followers · ${chalk.white(String(user.following))} following`);
+            if (user.isBlueVerified)
+                console.log(`  ${chalk.blue("✓ Verified")}`);
+            if (user.location)
+                console.log(`  ${chalk.gray(user.location)}`);
+        }
+        else {
+            console.log(formatJson(res.data));
+        }
     }
 }
 export async function twitterTrendsAction(options) {
     const key = requireApiKey();
     const spinner = ora("Fetching trends...").start();
-    const res = await apiRequest(key, "twitter/trends");
+    // woeid 1 = worldwide
+    const res = await apiRequest(key, "twitter/trends", {
+        query: { woeid: "1", count: "30" },
+        domain: true,
+    });
     if (!res.success) {
         spinner.fail("Failed to fetch trends");
         error(res.error || "Unknown error");

package/dist/commands/video.js

@@ -2,57 +2,72 @@ import ora from "ora";
 import chalk from "chalk";
 import { requireApiKey } from "../config.js";
 import { apiRequest } from "../api.js";
-import { error, success } from "../utils/display.js";
+import { error, formatJson, success } from "../utils/display.js";
 export async function videoCreateAction(prompt, options) {
     const key = requireApiKey();
     const spinner = ora("Creating video generation task...").start();
-    const body = { prompt };
-    if (options.model)
-        body.model = options.model;
+    const body = {
+        model: options.model || "wan2.6-t2v",
+        input: { prompt },
+        parameters: { resolution: "720P", duration: 5 },
+    };
     const res = await apiRequest(key, "services/aigc/video-generation/video-synthesis", {
         method: "POST",
         body,
+        headers: { "X-DashScope-Async": "enable" },
+        domain: true,
     });
     if (!res.success || !res.data) {
         spinner.fail("Failed to create video task");
         error(res.error || "Unknown error");
         return;
     }
-    const task = res.data;
     spinner.stop();
-    success(`Task created: ${task.taskId}`);
+    const taskId = res.data.output?.task_id || res.data.taskId;
+    if (!taskId) {
+        console.log(formatJson(res.data));
+        return;
+    }
+    success(`Task created: ${taskId}`);
     if (!options.wait) {
-        console.log(chalk.gray(`  Check status: aisa video status ${task.taskId}`));
+        console.log(chalk.gray(`  Check status: aisa video status ${taskId}`));
         return;
     }
     // Poll for completion
     const pollSpinner = ora("Generating video...").start();
-    let result = task;
-    while (result.status === "pending" || result.status === "processing") {
+    let status = "PENDING";
+    while (status === "PENDING" || status === "RUNNING") {
         await new Promise((r) => setTimeout(r, 5000));
-        const pollRes = await apiRequest(key, `services/aigc/tasks/${result.taskId}`);
+        const pollRes = await apiRequest(key, "services/aigc/tasks", {
+            query: { task_id: taskId },
+            domain: true,
+        });
         if (!pollRes.success || !pollRes.data) {
             pollSpinner.fail("Failed to check status");
             error(pollRes.error || "Unknown error");
             return;
         }
-        result = pollRes.data;
-        pollSpinner.text = `Generating video... (${result.status})`;
+        status = pollRes.data.output?.task_status || pollRes.data.status || "UNKNOWN";
+        pollSpinner.text = `Generating video... (${status})`;
     }
-    if (result.status === "completed") {
+    if (status === "SUCCEEDED" || status === "completed") {
         pollSpinner.succeed("Video generated!");
-        if (result.resultUrl) {
-            console.log(`  URL: ${chalk.cyan(result.resultUrl)}`);
+        const videoUrl = res.data.output?.video_url || res.data.resultUrl;
+        if (videoUrl) {
+            console.log(`  URL: ${chalk.cyan(videoUrl)}`);
         }
     }
     else {
-        pollSpinner.fail(`Video generation ${result.status}`);
+        pollSpinner.fail(`Video generation failed: ${status}`);
     }
 }
 export async function videoStatusAction(taskId, options) {
     const key = requireApiKey();
     const spinner = ora("Checking status...").start();
-    const res = await apiRequest(key, `services/aigc/tasks/${taskId}`);
+    const res = await apiRequest(key, "services/aigc/tasks", {
+        query: { task_id: taskId },
+        domain: true,
+    });
     if (!res.success || !res.data) {
         spinner.fail("Failed to check status");
         error(res.error || "Unknown error");
@@ -63,11 +78,15 @@ export async function videoStatusAction(taskId, options) {
         console.log(JSON.stringify(res.data));
     }
     else {
-        const t = res.data;
-        console.log(`  Task:   ${t.taskId}`);
-        console.log(`  Status: ${t.status}`);
-        console.log(`  Prompt: ${t.prompt}`);
-        if (t.resultUrl)
-            console.log(`  URL:    ${chalk.cyan(t.resultUrl)}`);
+        const d = res.data;
+        const status = d.output?.task_status || d.status || "unknown";
+        const id = d.output?.task_id || d.taskId || taskId;
+        const videoUrl = d.output?.video_url || d.resultUrl;
+        console.log(`  Task:   ${id}`);
+        console.log(`  Status: ${status}`);
+        if (videoUrl)
+            console.log(`  URL:    ${chalk.cyan(videoUrl)}`);
+        if (d.request_id)
+            console.log(`  Request: ${chalk.gray(d.request_id)}`);
     }
 }

package/dist/config.js

@@ -5,7 +5,7 @@ const config = new Conf({
     schema: {
         apiKey: { type: "string", default: "" },
         defaultModel: { type: "string", default: "gpt-4.1" },
-        baseUrl: { type: "string", default: "https://api.aisa.one" },
+        baseUrl: { type: "string", default: "https://api.aisa.one/v1" },
         outputFormat: { type: "string", default: "text" },
     },
 });

package/dist/constants.d.ts

@@ -1,6 +1,7 @@
-export declare const VERSION = "0.1.0";
+export declare const VERSION = "0.1.2";
 export declare const BASE_URL = "https://api.aisa.one";
 export declare const CLI_BASE_URL = "https://api.aisa.one/v1";
+export declare const APIS_BASE_URL = "https://api.aisa.one/apis/v1";
 export declare const ENV_VAR_NAME = "AISA_API_KEY";
 export declare const MCP_URL = "https://docs.aisa.one/mcp";
 export declare const AGENT_DIRS: Record<string, string>;

package/dist/constants.js

@@ -1,6 +1,7 @@
-export const VERSION = "0.1.0";
+export const VERSION = "0.1.2";
 export const BASE_URL = "https://api.aisa.one";
 export const CLI_BASE_URL = `${BASE_URL}/v1`;
+export const APIS_BASE_URL = `${BASE_URL}/apis/v1`;
 export const ENV_VAR_NAME = "AISA_API_KEY";
 export const MCP_URL = "https://docs.aisa.one/mcp";
 export const AGENT_DIRS = {

package/dist/index.js

@@ -143,7 +143,7 @@ program
 program
     .command("stock <symbol>")
     .description("Look up stock data")
-    .option("--field <field>", "Data field: price, earnings, financials, filings, insider, institutional", "price")
+    .option("--field <field>", "Data field: price, earnings, financials, filings, insider, institutional, metrics, news", "price")
     .option("--raw", "Raw JSON output")
     .action(wrap(stockAction));
 program

package/dist/types.d.ts

@@ -20,15 +20,10 @@ export interface ApiGroup {
 }
 export interface Model {
     id: string;
-    name: string;
-    provider: string;
-    contextWindow: number;
-    maxTokens: number;
-    pricing: {
-        input: number;
-        output: number;
-    };
-    capabilities: string[];
+    object: string;
+    created: number;
+    owned_by: string;
+    supported_endpoint_types?: string[] | null;
 }
 export interface SkillMeta {
     name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aisa-one/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "CLI for the AISA unified AI infrastructure platform - access 70+ LLMs, web search, finance, Twitter, and video generation APIs",
   "type": "module",
   "main": "dist/index.js",