@aisa-one/cli 0.2.2 → 0.2.4

package/dist/commands/finance.js

@@ -1,8 +1,12 @@
 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";
+import { apiRequest, cacheScope } from "../api.js";
+import { error, formatJson, hint } from "../utils/display.js";
+import { COINGECKO_IDS } from "../constants.js";
+import { readCache, writeCache } from "../cache.js";
+const coinListCacheKey = () => `coingecko/${cacheScope()}/coins-list.json`;
+const COIN_LIST_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const FIELD_ENDPOINTS = {
     info: "financial/company/facts",
     estimates: "financial/analyst-estimates",
@@ -89,61 +93,235 @@ export async function stockAction(symbol, options) {
         console.log(formatJson(res.data));
     }
 }
+const PERIOD_DAYS = { "1d": 1, "7d": 7, "30d": 30, "90d": 90, "1y": 365 };
+/**
+ * Resolve a user-typed symbol to a CoinGecko coin id: alias table first, then
+ * the full coin list (cached, ~18k entries). Ambiguous symbols are reported
+ * rather than guessed — picking one would silently price the wrong token.
+ */
+async function resolveCoinId(key, symbol) {
+    const lower = symbol.toLowerCase();
+    if (COINGECKO_IDS[lower])
+        return COINGECKO_IDS[lower];
+    const cached = readCache(coinListCacheKey());
+    let coins = cached?.fresh ? cached.data : undefined;
+    if (!coins) {
+        const res = await apiRequest(key, "coingecko/coins/list", { domain: true });
+        if (res.success && Array.isArray(res.data)) {
+            coins = res.data;
+            writeCache(coinListCacheKey(), coins, COIN_LIST_TTL_MS);
+        }
+        else {
+            coins = cached?.data;
+        }
+    }
+    if (!coins)
+        throw new Error(`Cannot resolve "${symbol}" — pass --id <coingecko-id>`);
+    // An exact id match is unambiguous, so accept it before considering symbols.
+    if (coins.some((c) => c.id === lower))
+        return lower;
+    const matches = coins.filter((c) => c.symbol.toLowerCase() === lower);
+    if (matches.length === 1)
+        return matches[0].id;
+    if (matches.length > 1) {
+        const shown = matches.slice(0, 8).map((c) => `${c.id} (${c.name})`);
+        throw new Error(`"${symbol}" matches ${matches.length} coins — pick one with --id:\n    ${shown.join("\n    ")}`);
+    }
+    throw new Error(`Unknown coin "${symbol}" — pass --id <coingecko-id>`);
+}
+function formatUsd(value) {
+    if (value >= 1)
+        return `$${value.toLocaleString("en-US", { maximumFractionDigits: 2 })}`;
+    return `$${value.toPrecision(4)}`;
+}
+function formatBig(value) {
+    if (value >= 1e12)
+        return `$${(value / 1e12).toFixed(2)}T`;
+    if (value >= 1e9)
+        return `$${(value / 1e9).toFixed(2)}B`;
+    if (value >= 1e6)
+        return `$${(value / 1e6).toFixed(2)}M`;
+    return `$${value.toFixed(0)}`;
+}
 export async function cryptoAction(symbol, options) {
     const key = requireApiKey();
+    // The financial provider's crypto endpoints return 403 for standard keys;
+    // coingecko covers the same ground and is cheaper, so it is the default.
+    if (options.source === "financial") {
+        return cryptoViaFinancial(key, symbol, options);
+    }
+    const spinner = ora(`Fetching ${symbol.toUpperCase()}...`).start();
+    let coinId;
+    try {
+        coinId = options.id || (await resolveCoinId(key, symbol));
+    }
+    catch (err) {
+        spinner.stop();
+        error(err.message);
+        return;
+    }
+    const historical = options.period && options.period !== "current";
+    const endpoint = historical
+        ? `coingecko/coins/${encodeURIComponent(coinId)}/market_chart`
+        : "coingecko/simple/price";
+    const query = historical
+        ? { vs_currency: "usd", days: String(PERIOD_DAYS[options.period] || 30) }
+        : {
+            ids: coinId,
+            vs_currencies: "usd",
+            include_market_cap: "true",
+            include_24hr_vol: "true",
+            include_24hr_change: "true",
+            include_last_updated_at: "true",
+        };
+    const res = await apiRequest(key, endpoint, { query, domain: true });
+    if (!res.success) {
+        spinner.fail("Failed to fetch crypto price");
+        error(res.error || "Unknown error");
+        return;
+    }
+    spinner.stop();
+    if (options.raw) {
+        console.log(JSON.stringify(res.data));
+        return;
+    }
+    if (historical) {
+        const prices = res.data.prices || [];
+        if (prices.length === 0) {
+            console.log(formatJson(res.data));
+            return;
+        }
+        const first = prices[0][1];
+        const last = prices[prices.length - 1][1];
+        const change = ((last - first) / first) * 100;
+        console.log(`\n  ${chalk.cyan.bold(coinId)} ${chalk.gray(`· ${options.period}`)}`);
+        console.log(`  Now:    ${formatUsd(last)}`);
+        console.log(`  Start:  ${formatUsd(first)}`);
+        console.log(`  Change: ${change >= 0 ? chalk.green(`+${change.toFixed(2)}%`) : chalk.red(`${change.toFixed(2)}%`)}`);
+        console.log(chalk.gray(`  ${prices.length} data points`));
+        console.log();
+        return;
+    }
+    const snapshot = res.data[coinId];
+    if (!snapshot) {
+        console.log(formatJson(res.data));
+        return;
+    }
+    const change = snapshot.usd_24h_change;
+    console.log(`\n  ${chalk.cyan.bold(coinId)} ${chalk.gray(`(${symbol.toUpperCase()})`)}`);
+    console.log(`  Price:     ${formatUsd(snapshot.usd)}`);
+    if (change != null) {
+        console.log(`  24h:       ${change >= 0 ? chalk.green(`+${change.toFixed(2)}%`) : chalk.red(`${change.toFixed(2)}%`)}`);
+    }
+    if (snapshot.usd_market_cap != null)
+        console.log(`  Mkt cap:   ${formatBig(snapshot.usd_market_cap)}`);
+    if (snapshot.usd_24h_vol != null)
+        console.log(`  24h vol:   ${formatBig(snapshot.usd_24h_vol)}`);
+    console.log();
+}
+/** Legacy path, kept behind --source for accounts that do have crypto access. */
+async function cryptoViaFinancial(key, symbol, options) {
     const spinner = ora(`Fetching ${symbol.toUpperCase()}...`).start();
-    // Format ticker: BTC → BTC-USD
     const ticker = symbol.toUpperCase().includes("-") ? symbol.toUpperCase() : `${symbol.toUpperCase()}-USD`;
-    let endpoint;
     const query = { ticker };
+    let endpoint;
     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));
+        start.setDate(start.getDate() - (PERIOD_DAYS[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];
+        query.end_date = new Date().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");
+        if ((res.error || "").includes("403")) {
+            hint("Crypto access is restricted on this provider — omit --source to use coingecko");
+        }
         return;
     }
     spinner.stop();
-    if (options.raw) {
-        console.log(JSON.stringify(res.data));
-    }
-    else {
-        console.log(formatJson(res.data));
+    console.log(options.raw ? JSON.stringify(res.data) : formatJson(res.data));
+}
+/**
+ * The screener matches sectors against GICS names, so the short forms people
+ * naturally type ("Technology", "Healthcare") silently return zero results.
+ */
+const GICS_SECTORS = [
+    "Energy",
+    "Materials",
+    "Industrials",
+    "Consumer Discretionary",
+    "Consumer Staples",
+    "Health Care",
+    "Financials",
+    "Information Technology",
+    "Communication Services",
+    "Utilities",
+    "Real Estate",
+];
+const SECTOR_ALIASES = {
+    tech: "Information Technology",
+    technology: "Information Technology",
+    it: "Information Technology",
+    healthcare: "Health Care",
+    health: "Health Care",
+    finance: "Financials",
+    financial: "Financials",
+    telecom: "Communication Services",
+    communications: "Communication Services",
+    consumer: "Consumer Discretionary",
+    staples: "Consumer Staples",
+    discretionary: "Consumer Discretionary",
+    realestate: "Real Estate",
+    utility: "Utilities",
+};
+function normalizeSector(input) {
+    const exact = GICS_SECTORS.find((s) => s.toLowerCase() === input.toLowerCase());
+    if (exact)
+        return exact;
+    return SECTOR_ALIASES[input.toLowerCase().replace(/[\s_-]/g, "")] || input;
+}
+/** Parse a `field:operator:value` filter, e.g. `market_cap:gt:1e12`. */
+function parseFilter(raw) {
+    const parts = raw.split(":");
+    if (parts.length < 3) {
+        throw new Error(`Invalid filter "${raw}". Use field:operator:value, e.g. market_cap:gt:1000000000`);
     }
+    const [field, operator, ...rest] = parts;
+    const value = rest.join(":");
+    const num = Number(value);
+    return { field, operator, value: value !== "" && !Number.isNaN(num) ? num : value };
 }
 export async function screenerAction(options) {
     const key = requireApiKey();
-    const spinner = ora("Running stock screener...").start();
-    const body = {
-        filters: [],
-    };
+    const filters = [];
     if (options.sector) {
-        body.filters.push({
-            field: "sector",
-            operator: "eq",
-            value: options.sector,
-        });
+        filters.push({ field: "sector", operator: "eq", value: normalizeSector(options.sector) });
+    }
+    if (options.minMarketCap) {
+        filters.push({ field: "market_cap", operator: "gt", value: Number(options.minMarketCap) });
+    }
+    for (const raw of options.filter || []) {
+        filters.push(parseFilter(raw));
+    }
+    // The upstream rejects an empty filter set outright, so give unfiltered runs
+    // a broad default rather than surfacing "Please include filters".
+    if (filters.length === 0) {
+        filters.push({ field: "market_cap", operator: "gt", value: 1_000_000_000 });
+        hint("No filters given — defaulting to market cap > $1B");
     }
+    const spinner = ora("Running stock screener...").start();
+    const body = { filters };
     if (options.limit)
         body.limit = parseInt(options.limit);
-    const res = await apiRequest(key, "financial/financials/search", {
-        method: "POST",
-        body,
-        domain: true,
-    });
+    const res = await apiRequest(key, "financial/financials/search/screener", { method: "POST", body, domain: true });
     if (!res.success) {
         spinner.fail("Screener failed");
         error(res.error || "Unknown error");
@@ -152,8 +330,13 @@ export async function screenerAction(options) {
     spinner.stop();
     if (options.raw) {
         console.log(JSON.stringify(res.data));
+        return;
     }
-    else {
-        console.log(formatJson(res.data));
+    const results = res.data?.results;
+    if (Array.isArray(results) && results.length === 0 && options.sector) {
+        console.log("  No matches.");
+        hint(`Sector must be a GICS name: ${GICS_SECTORS.join(", ")}`);
+        return;
     }
+    console.log(formatJson(res.data));
 }

package/dist/commands/models.js

@@ -3,6 +3,10 @@ import chalk from "chalk";
 import { requireApiKey } from "../config.js";
 import { apiRequest } from "../api.js";
 import { error, badge } from "../utils/display.js";
+import { writeCache } from "../cache.js";
+import { cacheScope } from "../api.js";
+const modelsCacheKey = () => `models/${cacheScope()}.json`;
+const MODELS_TTL_MS = 24 * 60 * 60 * 1000;
 export async function modelsListAction(options) {
     const key = requireApiKey();
     const spinner = ora("Fetching models...").start();
@@ -14,6 +18,8 @@ export async function modelsListAction(options) {
     }
     spinner.stop();
     let models = res.data.data;
+    // Cached purely so shell completion can offer model ids without a request.
+    writeCache(modelsCacheKey(), models, MODELS_TTL_MS);
     // Filter by provider if specified
     if (options.provider) {
         const filter = options.provider.toLowerCase();

package/dist/commands/run.d.ts

@@ -1,7 +1,28 @@
+export interface RunTarget {
+    /** Which base URL to use: the LLM gateway (/v1) or integration APIs (/apis/v1). */
+    base: "llm" | "domain";
+    /** Path relative to that base, with no leading slash. */
+    endpoint: string;
+}
+/**
+ * Decide which base URL a `run` invocation targets.
+ *
+ * Integration APIs are the default: there are ~29 providers and the set grows
+ * without a CLI release, so anything not recognised as an LLM gateway route
+ * goes to /apis/v1. See LLM_ROUTE_PREFIXES for why the whitelist sits on that
+ * side.
+ */
+export declare function resolveRunTarget(slug: string, path: string, options?: {
+    llm?: boolean;
+    domain?: boolean;
+}): RunTarget;
 export declare function runAction(slug: string, path: string, options: {
     q?: string[];
     d?: string;
     method?: string;
     raw?: boolean;
     stream?: boolean;
+    llm?: boolean;
+    domain?: boolean;
+    showCost?: boolean;
 }): Promise<void>;

package/dist/commands/run.js

@@ -1,8 +1,106 @@
+import chalk from "chalk";
 import ora from "ora";
 import { requireApiKey } from "../config.js";
-import { apiRequest, apiRequestRaw } from "../api.js";
-import { error, formatJson } from "../utils/display.js";
+import { apiRequest, apiRequestRaw, parseCost } from "../api.js";
+import { error, formatJson, hint } from "../utils/display.js";
 import { handleSSEStream } from "../utils/streaming.js";
+import { LLM_ROUTE_PREFIXES } from "../constants.js";
+import { getProviders } from "../catalog.js";
+/**
+ * Decide which base URL a `run` invocation targets.
+ *
+ * Integration APIs are the default: there are ~29 providers and the set grows
+ * without a CLI release, so anything not recognised as an LLM gateway route
+ * goes to /apis/v1. See LLM_ROUTE_PREFIXES for why the whitelist sits on that
+ * side.
+ */
+export function resolveRunTarget(slug, path, options = {}) {
+    const cleanSlug = slug.replace(/^\/+/, "").replace(/\/+$/, "");
+    const cleanPath = path.replace(/^\/+/, "");
+    const endpoint = cleanPath ? `${cleanSlug}/${cleanPath}` : cleanSlug;
+    let base;
+    if (options.llm) {
+        base = "llm";
+    }
+    else if (options.domain) {
+        base = "domain";
+    }
+    else {
+        base = LLM_ROUTE_PREFIXES.includes(cleanSlug.split("/")[0]) ? "llm" : "domain";
+    }
+    return { base, endpoint };
+}
+function editDistance(a, b) {
+    const prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        let diag = prev[0];
+        prev[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const temp = prev[j];
+            prev[j] = Math.min(prev[j] + 1, prev[j - 1] + 1, diag + (a[i - 1] === b[j - 1] ? 0 : 1));
+            diag = temp;
+        }
+    }
+    return prev[b.length];
+}
+/**
+ * Turn a 404 into a usable next step. This runs only on failure, so the catalog
+ * stays a diagnostic aid rather than something `run` depends on to work.
+ */
+async function suggestSlug(slug) {
+    try {
+        const providers = await getProviders();
+        const ids = providers.map((p) => p.id);
+        const near = ids
+            .map((id) => ({ id, d: editDistance(slug.toLowerCase(), id.toLowerCase()) }))
+            .filter((c) => c.d <= 3 || c.id.includes(slug) || slug.includes(c.id))
+            .sort((a, b) => a.d - b.d)
+            .slice(0, 3)
+            .map((c) => c.id);
+        if (near.length > 0) {
+            hint(`Did you mean: ${near.join(", ")}?`);
+        }
+        hint("List APIs: aisa api list");
+    }
+    catch {
+        // catalog unavailable — the error above is enough
+    }
+}
+/**
+ * Report what a call cost, on stderr so `--raw | jq` stays a clean pipe.
+ *
+ * Only metered routes report an amount; plain integration responses carry a
+ * price key and the LLM gateway sends no billing headers at all. Say so rather
+ * than printing nothing, so an empty report is not read as "this was free".
+ */
+function reportCost(cost) {
+    const dim = (label, value) => console.error(chalk.gray(`  ${label.padEnd(12)} ${value}`));
+    if (!cost) {
+        console.error(chalk.gray("  cost         not reported by this route"));
+        return;
+    }
+    if (cost.priceUsd)
+        dim("cost", `$${cost.priceUsd} USD`);
+    if (cost.accountedCredits) {
+        const estimate = cost.estimatedCredits && cost.estimatedCredits !== cost.accountedCredits
+            ? ` (estimated ${cost.estimatedCredits})`
+            : "";
+        dim("credits", `${cost.accountedCredits}${estimate}`);
+    }
+    if (cost.creditModel)
+        dim("credit model", cost.creditModel);
+    if (cost.pricingStrategy) {
+        const version = cost.pricingVersion ? ` v${cost.pricingVersion}` : "";
+        dim("pricing", `${cost.pricingStrategy}${version}`);
+    }
+    if (cost.priceKey)
+        dim("price key", cost.priceKey);
+    if (cost.requestId)
+        dim("request id", cost.requestId);
+    if (!cost.priceUsd) {
+        console.error(chalk.gray("  no amount reported — check `aisa account balance` for actual spend"));
+    }
+}
 export async function runAction(slug, path, options) {
     const key = requireApiKey();
     // Parse query params
@@ -31,10 +129,8 @@ export async function runAction(slug, path, options) {
     }
     // Detect method
     const method = (options.method || (body ? "POST" : "GET")).toUpperCase();
-    const endpoint = path.startsWith("/") ? `${slug}${path}` : `${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));
+    const { base, endpoint } = resolveRunTarget(slug, path, options);
+    const isDomain = base === "domain";
     // Streaming mode
     if (options.stream) {
         const res = await apiRequestRaw(key, endpoint, {
@@ -47,9 +143,13 @@ export async function runAction(slug, path, options) {
         if (!res.ok) {
             const text = await res.text();
             error(`${res.status}: ${text}`);
+            if (options.showCost)
+                reportCost(parseCost(res));
             return;
         }
         await handleSSEStream(res, (token) => process.stdout.write(token), () => console.log());
+        if (options.showCost)
+            reportCost(parseCost(res));
         return;
     }
     // Normal mode
@@ -63,6 +163,11 @@ export async function runAction(slug, path, options) {
     if (!res.success) {
         spinner.fail("API call failed");
         error(res.error || "Unknown error");
+        if (isDomain && (res.error || "").includes("api endpoint not found")) {
+            await suggestSlug(slug);
+        }
+        if (options.showCost)
+            reportCost(res.cost);
         return;
     }
     spinner.stop();
@@ -72,4 +177,6 @@ export async function runAction(slug, path, options) {
     else {
         console.log(formatJson(res.data));
     }
+    if (options.showCost)
+        reportCost(res.cost);
 }

package/dist/commands/search.js

@@ -2,10 +2,10 @@ 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";
+import { error, formatJson, hint } from "../utils/display.js";
 export async function webSearchAction(query, options) {
     const key = requireApiKey();
-    const type = options.type || "smart";
+    const type = options.type || "tavily";
     const spinner = ora(`Searching (${type})...`).start();
     const endpointMap = {
         smart: { endpoint: "search/smart", method: "GET", paramStyle: "query" },
@@ -17,7 +17,7 @@ export async function webSearchAction(query, options) {
     const config = endpointMap[type];
     if (!config) {
         spinner.fail(`Unknown search type: ${type}`);
-        error("Valid types: smart, full, youtube, scholar, tavily");
+        error("Valid types: tavily, youtube, scholar, smart, full");
         return;
     }
     // Build request options
@@ -44,6 +44,11 @@ export async function webSearchAction(query, options) {
     if (!res.success) {
         spinner.fail("Search failed");
         error(res.error || "Unknown error");
+        // smart/full currently proxy to an upstream that 404s for every parameter
+        // shape; steer users to a working backend rather than to parameter tweaks.
+        if (type === "smart" || type === "full") {
+            hint(`The '${type}' backend is currently degraded — try --type tavily`);
+        }
         return;
     }
     spinner.stop();

package/dist/commands/skills.d.ts

@@ -1,16 +1,20 @@
-export declare function skillsListAction(_options: {
+export declare function skillsListAction(options: {
     category?: string;
     limit?: string;
+    refresh?: boolean;
 }): Promise<void>;
-export declare function skillsSearchAction(query: string, _options: {
+export declare function skillsSearchAction(query: string, options: {
     limit?: string;
+    refresh?: boolean;
 }): Promise<void>;
 export declare function skillsShowAction(slug: string): Promise<void>;
 export declare function skillsInstallAction(slug: string, options: {
     agent?: string;
+    force?: boolean;
 }): Promise<void>;
 export declare function skillsRemoveAction(slug: string, options: {
     agent?: string;
+    force?: boolean;
 }): void;
 export declare function skillsInitAction(name: string, options: {
     template?: string;