@aisa-one/cli 0.0.1 → 0.1.0

package/dist/commands/finance.js

@@ -0,0 +1,85 @@
+import ora from "ora";
+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",
+};
+export async function stockAction(symbol, options) {
+    const key = requireApiKey();
+    const field = options.field || "price";
+    const endpoint = FIELD_ENDPOINTS[field];
+    if (!endpoint) {
+        error(`Unknown field: ${field}. Valid: ${Object.keys(FIELD_ENDPOINTS).join(", ")}`);
+        return;
+    }
+    const spinner = ora(`Fetching ${field} for ${symbol.toUpperCase()}...`).start();
+    const res = await apiRequest(key, endpoint, {
+        query: { symbol: symbol.toUpperCase() },
+    });
+    if (!res.success) {
+        spinner.fail(`Failed to fetch ${field}`);
+        error(res.error || "Unknown error");
+        return;
+    }
+    spinner.stop();
+    if (options.raw) {
+        console.log(JSON.stringify(res.data));
+    }
+    else {
+        console.log(formatJson(res.data));
+    }
+}
+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 });
+    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));
+    }
+    else {
+        console.log(formatJson(res.data));
+    }
+}
+export async function screenerAction(options) {
+    const key = requireApiKey();
+    const spinner = ora("Running stock screener...").start();
+    const body = {};
+    if (options.sector)
+        body.sector = options.sector;
+    if (options.limit)
+        body.limit = parseInt(options.limit);
+    const res = await apiRequest(key, "search/financials", {
+        method: "POST",
+        body,
+    });
+    if (!res.success) {
+        spinner.fail("Screener failed");
+        error(res.error || "Unknown error");
+        return;
+    }
+    spinner.stop();
+    if (options.raw) {
+        console.log(JSON.stringify(res.data));
+    }
+    else {
+        console.log(formatJson(res.data));
+    }
+}

package/dist/commands/mcp.d.ts

@@ -0,0 +1,4 @@
+export declare function mcpSetupAction(options: {
+    agent?: string;
+}): void;
+export declare function mcpStatusAction(): void;

package/dist/commands/mcp.js

@@ -0,0 +1,67 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import chalk from "chalk";
+import { success, error, info, hint } from "../utils/display.js";
+import { expandHome, ensureDir } from "../utils/file.js";
+import { MCP_CONFIGS, MCP_URL } from "../constants.js";
+import { join } from "node:path";
+export function mcpSetupAction(options) {
+    const targets = options.agent && options.agent !== "all"
+        ? [options.agent]
+        : Object.keys(MCP_CONFIGS);
+    let configured = 0;
+    for (const agent of targets) {
+        const config = MCP_CONFIGS[agent];
+        if (!config) {
+            error(`Unknown agent: ${agent}. Valid: ${Object.keys(MCP_CONFIGS).join(", ")}, all`);
+            return;
+        }
+        const filePath = expandHome(config.path);
+        let existing = {};
+        if (existsSync(filePath)) {
+            try {
+                existing = JSON.parse(readFileSync(filePath, "utf-8"));
+            }
+            catch {
+                existing = {};
+            }
+        }
+        else {
+            ensureDir(join(filePath, ".."));
+        }
+        const servers = existing[config.key] || {};
+        servers["aisa"] = { url: MCP_URL };
+        existing[config.key] = servers;
+        writeFileSync(filePath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+        console.log(`  ${chalk.green("✓")} ${agent}: ${config.path}`);
+        configured++;
+    }
+    if (configured > 0) {
+        success(`MCP server configured for ${configured} agent(s)`);
+        hint("Restart your agent/editor to activate");
+    }
+}
+export function mcpStatusAction() {
+    info(`MCP Server: ${MCP_URL}`);
+    for (const [agent, config] of Object.entries(MCP_CONFIGS)) {
+        const filePath = expandHome(config.path);
+        if (existsSync(filePath)) {
+            try {
+                const data = JSON.parse(readFileSync(filePath, "utf-8"));
+                const servers = data[config.key];
+                if (servers?.["aisa"]) {
+                    console.log(`  ${chalk.green("✓")} ${agent}: configured`);
+                }
+                else {
+                    console.log(`  ${chalk.gray("○")} ${agent}: not configured`);
+                }
+            }
+            catch {
+                console.log(`  ${chalk.gray("○")} ${agent}: config unreadable`);
+            }
+        }
+        else {
+            console.log(`  ${chalk.gray("○")} ${agent}: not installed`);
+        }
+    }
+    hint("Run 'aisa mcp setup' to configure");
+}

package/dist/commands/models.d.ts

@@ -0,0 +1,4 @@
+export declare function modelsListAction(options: {
+    provider?: string;
+}): Promise<void>;
+export declare function modelsShowAction(modelId: string): Promise<void>;

package/dist/commands/models.js

@@ -0,0 +1,65 @@
+import ora from "ora";
+import chalk from "chalk";
+import { requireApiKey } from "../config.js";
+import { apiRequest } from "../api.js";
+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 });
+    if (!res.success || !res.data) {
+        spinner.fail("Failed to fetch models");
+        error(res.error || "Unknown error");
+        return;
+    }
+    spinner.stop();
+    const models = res.data.data;
+    if (models.length === 0) {
+        console.log("  No models found.");
+        return;
+    }
+    // Group by provider
+    const grouped = {};
+    for (const m of models) {
+        const p = m.provider || "other";
+        if (!grouped[p])
+            grouped[p] = [];
+        grouped[p].push(m);
+    }
+    for (const [provider, pModels] of Object.entries(grouped)) {
+        console.log(`\n  ${chalk.cyan.bold(provider.toUpperCase())}`);
+        for (const m of pModels) {
+            console.log(`    ${chalk.white(m.id)}`);
+        }
+    }
+    console.log(chalk.gray(`\n  ${models.length} models available`));
+    console.log(chalk.gray("  Run 'aisa models show <model-id>' for details"));
+}
+export async function modelsShowAction(modelId) {
+    const key = requireApiKey();
+    const spinner = ora(`Loading ${modelId}...`).start();
+    const res = await apiRequest(key, `models/${modelId}`);
+    if (!res.success || !res.data) {
+        spinner.fail("Model not found");
+        error(res.error || "Unknown error");
+        return;
+    }
+    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(chalk.gray(`\n  Use: aisa chat "message" --model ${m.id}`));
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,7 @@
+export declare function runAction(slug: string, path: string, options: {
+    q?: string[];
+    d?: string;
+    method?: string;
+    raw?: boolean;
+    stream?: boolean;
+}): Promise<void>;

package/dist/commands/run.js

@@ -0,0 +1,70 @@
+import ora from "ora";
+import { requireApiKey } from "../config.js";
+import { apiRequest, apiRequestRaw } from "../api.js";
+import { error, formatJson } from "../utils/display.js";
+import { handleSSEStream } from "../utils/streaming.js";
+export async function runAction(slug, path, options) {
+    const key = requireApiKey();
+    // Parse query params
+    const query = {};
+    if (options.q) {
+        for (const q of options.q) {
+            const pairs = q.split("&");
+            for (const pair of pairs) {
+                const eqIdx = pair.indexOf("=");
+                if (eqIdx > 0) {
+                    query[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+                }
+            }
+        }
+    }
+    // Parse body
+    let body;
+    if (options.d) {
+        try {
+            body = JSON.parse(options.d);
+        }
+        catch {
+            error("Invalid JSON body. Use -d '{\"key\": \"value\"}'");
+            process.exit(1);
+        }
+    }
+    // Detect method
+    const method = (options.method || (body ? "POST" : "GET")).toUpperCase();
+    const endpoint = `${slug}${path}`;
+    // Streaming mode
+    if (options.stream) {
+        const res = await apiRequestRaw(key, endpoint, {
+            method,
+            query: Object.keys(query).length > 0 ? query : undefined,
+            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), () => console.log());
+        return;
+    }
+    // Normal mode
+    const spinner = ora(`Calling ${slug} ${path}...`).start();
+    const res = await apiRequest(key, endpoint, {
+        method,
+        query: Object.keys(query).length > 0 ? query : undefined,
+        body,
+    });
+    if (!res.success) {
+        spinner.fail("API call failed");
+        error(res.error || "Unknown error");
+        return;
+    }
+    spinner.stop();
+    if (options.raw) {
+        console.log(JSON.stringify(res.data));
+    }
+    else {
+        console.log(formatJson(res.data));
+    }
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,9 @@
+export declare function webSearchAction(query: string, options: {
+    type?: string;
+    limit?: string;
+    raw?: boolean;
+}): Promise<void>;
+export declare function scholarAction(query: string, options: {
+    limit?: string;
+    raw?: boolean;
+}): Promise<void>;

package/dist/commands/search.js

@@ -0,0 +1,43 @@
+import ora from "ora";
+import { requireApiKey } from "../config.js";
+import { apiRequest } from "../api.js";
+import { error, formatJson } from "../utils/display.js";
+export async function webSearchAction(query, options) {
+    const key = requireApiKey();
+    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" },
+    };
+    const config = endpointMap[type];
+    if (!config) {
+        spinner.fail(`Unknown search type: ${type}`);
+        error("Valid types: smart, full, youtube, scholar, tavily");
+        return;
+    }
+    const res = await apiRequest(key, config.endpoint, {
+        method: config.method,
+        ...(config.method === "GET"
+            ? { query: { query, ...(options.limit ? { limit: options.limit } : {}) } }
+            : { body: { query, limit: parseInt(options.limit || "10") } }),
+    });
+    if (!res.success) {
+        spinner.fail("Search failed");
+        error(res.error || "Unknown error");
+        return;
+    }
+    spinner.stop();
+    if (options.raw) {
+        console.log(JSON.stringify(res.data));
+    }
+    else {
+        console.log(formatJson(res.data));
+    }
+}
+export async function scholarAction(query, options) {
+    return webSearchAction(query, { type: "scholar", ...options });
+}

package/dist/commands/skills.d.ts

@@ -0,0 +1,22 @@
+export declare function skillsListAction(options: {
+    category?: string;
+    limit?: string;
+}): Promise<void>;
+export declare function skillsSearchAction(query: string, options: {
+    limit?: string;
+}): Promise<void>;
+export declare function skillsShowAction(slug: string): Promise<void>;
+export declare function skillsAddAction(slug: string, options: {
+    agent?: string;
+}): Promise<void>;
+export declare function skillsRemoveAction(slug: string, options: {
+    agent?: string;
+}): Promise<void>;
+export declare function skillsInitAction(name: string, options: {
+    template?: string;
+    bare?: boolean;
+}): void;
+export declare function skillsSubmitAction(path: string): Promise<void>;
+export declare function skillsPushAction(slug: string): Promise<void>;
+export declare function skillsVerifyAction(slug: string): Promise<void>;
+export declare function skillsUpdateAction(slug?: string): Promise<void>;