@aisa-one/cli 0.0.1 → 0.1.0

package/dist/commands/video.js

@@ -0,0 +1,73 @@
+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";
+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 res = await apiRequest(key, "services/aigc/video-generation/video-synthesis", {
+        method: "POST",
+        body,
+    });
+    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}`);
+    if (!options.wait) {
+        console.log(chalk.gray(`  Check status: aisa video status ${task.taskId}`));
+        return;
+    }
+    // Poll for completion
+    const pollSpinner = ora("Generating video...").start();
+    let result = task;
+    while (result.status === "pending" || result.status === "processing") {
+        await new Promise((r) => setTimeout(r, 5000));
+        const pollRes = await apiRequest(key, `services/aigc/tasks/${result.taskId}`);
+        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})`;
+    }
+    if (result.status === "completed") {
+        pollSpinner.succeed("Video generated!");
+        if (result.resultUrl) {
+            console.log(`  URL: ${chalk.cyan(result.resultUrl)}`);
+        }
+    }
+    else {
+        pollSpinner.fail(`Video generation ${result.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}`);
+    if (!res.success || !res.data) {
+        spinner.fail("Failed to check status");
+        error(res.error || "Unknown error");
+        return;
+    }
+    spinner.stop();
+    if (options.raw) {
+        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)}`);
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,10 @@
+export declare function getApiKey(): string | undefined;
+export declare function requireApiKey(): string;
+export declare function setApiKey(key: string): void;
+export declare function clearApiKey(): void;
+export declare function getKeySource(): "env" | "config" | "none";
+export declare function getConfig(key: string): unknown;
+export declare function setConfig(key: string, value: string): void;
+export declare function listConfig(): Record<string, unknown>;
+export declare function resetConfig(): void;
+export declare function maskKey(key: string): string;

package/dist/config.js

@@ -0,0 +1,56 @@
+import Conf from "conf";
+import { ENV_VAR_NAME } from "./constants.js";
+const config = new Conf({
+    projectName: "aisa-cli",
+    schema: {
+        apiKey: { type: "string", default: "" },
+        defaultModel: { type: "string", default: "gpt-4.1" },
+        baseUrl: { type: "string", default: "https://api.aisa.one" },
+        outputFormat: { type: "string", default: "text" },
+    },
+});
+export function getApiKey() {
+    const envKey = process.env[ENV_VAR_NAME];
+    if (envKey)
+        return envKey;
+    const stored = config.get("apiKey");
+    return stored || undefined;
+}
+export function requireApiKey() {
+    const key = getApiKey();
+    if (!key) {
+        console.error(`No API key found. Run "aisa login --key <key>" or set ${ENV_VAR_NAME}.`);
+        process.exit(1);
+    }
+    return key;
+}
+export function setApiKey(key) {
+    config.set("apiKey", key);
+}
+export function clearApiKey() {
+    config.delete("apiKey");
+}
+export function getKeySource() {
+    if (process.env[ENV_VAR_NAME])
+        return "env";
+    if (config.get("apiKey"))
+        return "config";
+    return "none";
+}
+export function getConfig(key) {
+    return config.get(key);
+}
+export function setConfig(key, value) {
+    config.set(key, value);
+}
+export function listConfig() {
+    return config.store;
+}
+export function resetConfig() {
+    config.clear();
+}
+export function maskKey(key) {
+    if (key.length <= 8)
+        return "****";
+    return key.slice(0, 4) + "..." + key.slice(-4);
+}

package/dist/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const VERSION = "0.1.0";
+export declare const BASE_URL = "https://api.aisa.one";
+export declare const CLI_BASE_URL = "https://api.aisa.one/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>;
+export declare const MCP_CONFIGS: Record<string, {
+    path: string;
+    key: string;
+}>;
+export declare const API_CATEGORIES: readonly ["llm", "search", "finance", "twitter", "video", "scholar"];
+export type ApiCategory = (typeof API_CATEGORIES)[number];
+export declare const MODEL_PROVIDERS: readonly ["openai", "anthropic", "google", "deepseek", "xai", "moonshot", "alibaba", "bytedance"];
+export type ModelProvider = (typeof MODEL_PROVIDERS)[number];

package/dist/constants.js

@@ -0,0 +1,43 @@
+export const VERSION = "0.1.0";
+export const BASE_URL = "https://api.aisa.one";
+export const CLI_BASE_URL = `${BASE_URL}/v1`;
+export const ENV_VAR_NAME = "AISA_API_KEY";
+export const MCP_URL = "https://docs.aisa.one/mcp";
+export const AGENT_DIRS = {
+    claude: "~/.claude/skills/",
+    cursor: "~/.cursor/skills/",
+    copilot: "~/.github/skills/",
+    windsurf: "~/.codeium/windsurf/skills/",
+    codex: "~/.agents/skills/",
+    gemini: "~/.gemini/skills/",
+    openclaw: "~/.openclaw/skills/",
+};
+export const MCP_CONFIGS = {
+    cursor: { path: "~/.cursor/mcp.json", key: "mcpServers" },
+    "claude-desktop": {
+        path: "~/Library/Application Support/Claude/claude_desktop_config.json",
+        key: "mcpServers",
+    },
+    windsurf: {
+        path: "~/.codeium/windsurf/mcp_config.json",
+        key: "mcpServers",
+    },
+};
+export const API_CATEGORIES = [
+    "llm",
+    "search",
+    "finance",
+    "twitter",
+    "video",
+    "scholar",
+];
+export const MODEL_PROVIDERS = [
+    "openai",
+    "anthropic",
+    "google",
+    "deepseek",
+    "xai",
+    "moonshot",
+    "alibaba",
+    "bytedance",
+];

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { VERSION } from "./constants.js";
+// Auth
+import { loginAction, logoutAction, whoamiAction } from "./commands/auth.js";
+// Account
+import { balanceAction, usageAction } from "./commands/account.js";
+// API
+import { apiListAction, apiSearchAction, apiShowAction, apiCodeAction } from "./commands/api.js";
+// Run
+import { runAction } from "./commands/run.js";
+// Chat
+import { chatAction } from "./commands/chat.js";
+// Models
+import { modelsListAction, modelsShowAction } from "./commands/models.js";
+// Search
+import { webSearchAction, scholarAction } from "./commands/search.js";
+// Finance
+import { stockAction, cryptoAction, screenerAction } from "./commands/finance.js";
+// Twitter
+import { tweetAction, twitterSearchAction, twitterUserAction, twitterTrendsAction } from "./commands/twitter.js";
+// Video
+import { videoCreateAction, videoStatusAction } from "./commands/video.js";
+// Skills
+import { skillsListAction, skillsSearchAction, skillsShowAction, skillsAddAction, skillsRemoveAction, skillsUpdateAction, skillsInitAction, skillsSubmitAction, skillsPushAction, skillsVerifyAction, } from "./commands/skills.js";
+// MCP
+import { mcpSetupAction, mcpStatusAction } from "./commands/mcp.js";
+// Config
+import { configSetAction, configGetAction, configListAction, configResetAction } from "./commands/configCmd.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function wrap(fn) {
+    return (...args) => {
+        fn(...args).catch((err) => {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        });
+    };
+}
+const program = new Command();
+program
+    .name("aisa")
+    .description("AISA CLI - Unified AI infrastructure platform")
+    .version(VERSION);
+// ── Auth ──
+program
+    .command("login")
+    .description("Authenticate with your AISA API key")
+    .option("--key <key>", "API key")
+    .action(loginAction);
+program
+    .command("logout")
+    .description("Remove stored API key")
+    .action(logoutAction);
+program
+    .command("whoami")
+    .description("Show authentication status")
+    .action(whoamiAction);
+// ── Account ──
+program
+    .command("balance")
+    .description("Show credit balance")
+    .action(wrap(balanceAction));
+program
+    .command("usage")
+    .description("Show usage history")
+    .option("--limit <n>", "Max records")
+    .option("--days <n>", "Lookback days")
+    .action(wrap(usageAction));
+// ── API ──
+const api = program.command("api").description("Discover and inspect APIs");
+api
+    .command("list")
+    .description("List available API endpoints")
+    .option("--category <cat>", "Filter by category (llm, search, finance, twitter, video, scholar)")
+    .action(wrap(apiListAction));
+api
+    .command("search <query>")
+    .description("Search APIs by keyword")
+    .option("--limit <n>", "Max results")
+    .action(wrap(apiSearchAction));
+api
+    .command("show <slug> [path]")
+    .description("Show API endpoint details")
+    .action(wrap(apiShowAction));
+api
+    .command("code <slug> <path>")
+    .description("Generate code snippet")
+    .option("--lang <language>", "Language: typescript, python, curl", "typescript")
+    .action(wrap(apiCodeAction));
+// ── Run ──
+program
+    .command("run <slug> <path>")
+    .description("Execute an API call")
+    .option("-q, --query <params...>", "Query parameters (key=value)")
+    .option("-d, --data <json>", "JSON request body")
+    .option("--method <method>", "HTTP method")
+    .option("--raw", "Raw JSON output")
+    .option("--stream", "Stream response")
+    .action((slug, path, opts) => wrap(runAction)(slug, path, {
+    q: opts.query,
+    d: opts.data,
+    method: opts.method,
+    raw: opts.raw,
+    stream: opts.stream,
+}));
+// ── Chat (LLM Gateway) ──
+program
+    .command("chat [message]")
+    .description("Chat with AI models via the AISA gateway")
+    .option("--model <model>", "Model ID (default: gpt-4.1)")
+    .option("--system <prompt>", "System prompt")
+    .option("--no-stream", "Disable streaming")
+    .option("--json", "Output raw JSON response")
+    .option("--max-tokens <n>", "Max output tokens")
+    .option("--temperature <t>", "Sampling temperature (0-2)")
+    .action(wrap(chatAction));
+// ── Models ──
+const models = program.command("models").description("Browse available LLM models");
+models
+    .command("list", { isDefault: true })
+    .description("List all models")
+    .option("--provider <provider>", "Filter by provider")
+    .action(wrap(modelsListAction));
+models
+    .command("show <model-id>")
+    .description("Show model details and pricing")
+    .action(wrap(modelsShowAction));
+// ── Search shortcuts ──
+program
+    .command("web-search <query>")
+    .description("Search the web")
+    .option("--type <type>", "Search type: smart, full, youtube, scholar, tavily", "smart")
+    .option("--limit <n>", "Max results")
+    .option("--raw", "Raw JSON output")
+    .action(wrap(webSearchAction));
+program
+    .command("scholar <query>")
+    .description("Search academic papers")
+    .option("--limit <n>", "Max results")
+    .option("--raw", "Raw JSON output")
+    .action(wrap(scholarAction));
+// ── Finance shortcuts ──
+program
+    .command("stock <symbol>")
+    .description("Look up stock data")
+    .option("--field <field>", "Data field: price, earnings, financials, filings, insider, institutional", "price")
+    .option("--raw", "Raw JSON output")
+    .action(wrap(stockAction));
+program
+    .command("crypto <symbol>")
+    .description("Look up crypto price")
+    .option("--period <period>", "Time period: current, 1d, 7d, 30d, 1y")
+    .option("--raw", "Raw JSON output")
+    .action(wrap(cryptoAction));
+program
+    .command("screener")
+    .description("Screen stocks by criteria")
+    .option("--sector <sector>", "Filter by sector")
+    .option("--limit <n>", "Max results")
+    .option("--raw", "Raw JSON output")
+    .action(wrap(screenerAction));
+// ── Twitter shortcuts ──
+program
+    .command("tweet <text>")
+    .description("Post a tweet")
+    .option("--reply-to <id>", "Reply to tweet ID")
+    .option("--raw", "Raw JSON output")
+    .action(wrap(tweetAction));
+const twitter = program.command("twitter").description("Twitter/X operations");
+twitter
+    .command("search <query>")
+    .description("Search tweets")
+    .option("--limit <n>", "Max results")
+    .option("--raw", "Raw JSON output")
+    .action(wrap(twitterSearchAction));
+twitter
+    .command("user <username>")
+    .description("Get user profile")
+    .option("--raw", "Raw JSON output")
+    .action(wrap(twitterUserAction));
+twitter
+    .command("trends")
+    .description("Get trending topics")
+    .option("--raw", "Raw JSON output")
+    .action(wrap(twitterTrendsAction));
+// ── Video shortcuts ──
+const video = program.command("video").description("AI video generation");
+video
+    .command("create <prompt>")
+    .description("Create a video generation task")
+    .option("--model <model>", "Generation model")
+    .option("--wait", "Wait for completion")
+    .option("--output <path>", "Download output path")
+    .option("--raw", "Raw JSON output")
+    .action(wrap(videoCreateAction));
+video
+    .command("status <task-id>")
+    .description("Check video task status")
+    .option("--raw", "Raw JSON output")
+    .action(wrap(videoStatusAction));
+// ── Skills ──
+const skills = program.command("skills").description("Browse and manage agent skills");
+skills
+    .command("list")
+    .description("List available skills")
+    .option("--category <cat>", "Filter by category")
+    .option("--limit <n>", "Max results")
+    .action(wrap(skillsListAction));
+skills
+    .command("search <query>")
+    .description("Search skills")
+    .option("--limit <n>", "Max results")
+    .action(wrap(skillsSearchAction));
+skills
+    .command("show <slug>")
+    .description("Show skill details")
+    .action(wrap(skillsShowAction));
+skills
+    .command("add <slug>")
+    .description("Install a skill to agent directories")
+    .option("--agent <agent>", "Target agent: claude, cursor, copilot, windsurf, codex, gemini, openclaw, all")
+    .action(wrap(skillsAddAction));
+skills
+    .command("remove <slug>")
+    .description("Remove an installed skill")
+    .option("--agent <agent>", "Target agent")
+    .action(skillsRemoveAction);
+skills
+    .command("update [slug]")
+    .description("Update installed skill(s)")
+    .action(wrap(skillsUpdateAction));
+skills
+    .command("init <name>")
+    .description("Initialize a new skill")
+    .option("--template <template>", "Template: llm, search, finance, twitter, video")
+    .option("--bare", "Minimal template")
+    .action(skillsInitAction);
+skills
+    .command("submit <path>")
+    .description("Submit a skill to AISA")
+    .action(wrap(skillsSubmitAction));
+skills
+    .command("push <slug>")
+    .description("Push local changes to a submitted skill")
+    .action(wrap(skillsPushAction));
+skills
+    .command("request-verification <slug>")
+    .description("Request skill verification")
+    .action(wrap(skillsVerifyAction));
+// ── MCP ──
+const mcp = program.command("mcp").description("MCP server integration");
+mcp
+    .command("setup")
+    .description("Configure AISA MCP server for AI agents")
+    .option("--agent <agent>", "Target agent: cursor, claude-desktop, windsurf, all")
+    .action(mcpSetupAction);
+mcp
+    .command("status")
+    .description("Check MCP server configuration status")
+    .action(mcpStatusAction);
+// ── Config ──
+const configCmd = program.command("config").description("Manage CLI configuration");
+configCmd
+    .command("set <key> <value>")
+    .description("Set a config value")
+    .action(configSetAction);
+configCmd
+    .command("get <key>")
+    .description("Get a config value")
+    .action(configGetAction);
+configCmd
+    .command("list")
+    .description("List all config values")
+    .action(configListAction);
+configCmd
+    .command("reset")
+    .description("Reset config to defaults")
+    .action(configResetAction);
+// ── Top-level aliases ──
+program
+    .command("search <query>")
+    .description("Search APIs (alias for 'api search')")
+    .option("--limit <n>", "Max results")
+    .action(wrap(apiSearchAction));
+program
+    .command("code <slug> <path>")
+    .description("Generate code (alias for 'api code')")
+    .option("--lang <language>", "Language", "typescript")
+    .action(wrap(apiCodeAction));
+// ── Parse ──
+program.parse();

package/dist/types.d.ts

@@ -0,0 +1,100 @@
+export interface ApiEndpoint {
+    method: string;
+    path: string;
+    description: string;
+    category: string;
+    parameters?: Parameter[];
+}
+export interface Parameter {
+    name: string;
+    type: string;
+    required: boolean;
+    description: string;
+}
+export interface ApiGroup {
+    slug: string;
+    name: string;
+    description: string;
+    category: string;
+    endpoints: ApiEndpoint[];
+}
+export interface Model {
+    id: string;
+    name: string;
+    provider: string;
+    contextWindow: number;
+    maxTokens: number;
+    pricing: {
+        input: number;
+        output: number;
+    };
+    capabilities: string[];
+}
+export interface SkillMeta {
+    name: string;
+    description: string;
+    owner: string;
+    slug: string;
+    tags: string[];
+    category: string;
+    verified: boolean;
+    installs: number;
+}
+export interface SkillDetail extends SkillMeta {
+    files: Array<{
+        path: string;
+        content: string;
+    }>;
+}
+export interface BalanceResponse {
+    balance: number;
+    currency: string;
+}
+export interface UsageRecord {
+    timestamp: string;
+    api: string;
+    endpoint: string;
+    cost: number;
+    tokens?: {
+        input: number;
+        output: number;
+    };
+    status: "success" | "error";
+}
+export interface ChatOptions {
+    model: string;
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    stream: boolean;
+    max_tokens?: number;
+    temperature?: number;
+}
+export interface ChatResponse {
+    id: string;
+    choices: Array<{
+        message: {
+            role: string;
+            content: string;
+        };
+        finish_reason: string;
+    }>;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+export interface VideoTask {
+    taskId: string;
+    status: "pending" | "processing" | "completed" | "failed";
+    prompt: string;
+    resultUrl?: string;
+    createdAt: string;
+}
+export interface ApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/display.d.ts

@@ -0,0 +1,8 @@
+export declare function table(headers: string[], rows: string[][]): string;
+export declare function badge(text: string, color?: "green" | "blue" | "yellow" | "red" | "gray"): string;
+export declare function success(msg: string): void;
+export declare function error(msg: string): void;
+export declare function info(msg: string): void;
+export declare function hint(msg: string): void;
+export declare function formatJson(data: unknown): string;
+export declare function truncate(str: string, maxLen: number): string;

package/dist/utils/display.js

@@ -0,0 +1,33 @@
+import chalk from "chalk";
+export function table(headers, rows) {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] || "").length)));
+    const sep = widths.map((w) => "─".repeat(w + 2)).join("┼");
+    const headerLine = headers
+        .map((h, i) => ` ${chalk.bold(h.padEnd(widths[i]))} `)
+        .join("│");
+    const dataLines = rows.map((row) => row.map((cell, i) => ` ${(cell || "").padEnd(widths[i])} `).join("│"));
+    return [headerLine, sep, ...dataLines].join("\n");
+}
+export function badge(text, color = "blue") {
+    return chalk[color](`[${text}]`);
+}
+export function success(msg) {
+    console.log(chalk.green("✓") + " " + msg);
+}
+export function error(msg) {
+    console.error(chalk.red("✗") + " " + msg);
+}
+export function info(msg) {
+    console.log(chalk.blue("ℹ") + " " + msg);
+}
+export function hint(msg) {
+    console.log(chalk.gray("  " + msg));
+}
+export function formatJson(data) {
+    return JSON.stringify(data, null, 2);
+}
+export function truncate(str, maxLen) {
+    if (str.length <= maxLen)
+        return str;
+    return str.slice(0, maxLen - 3) + "...";
+}

package/dist/utils/file.d.ts

@@ -0,0 +1,12 @@
+export declare function expandHome(p: string): string;
+export declare function ensureDir(dirPath: string): void;
+export declare function writeSkillFiles(targetDir: string, files: Array<{
+    path: string;
+    content: string;
+}>): void;
+export declare function readSkillDir(dirPath: string): Array<{
+    path: string;
+    content: string;
+}>;
+export declare function removeDir(dirPath: string): void;
+export declare function detectAgents(agentDirs: Record<string, string>): string[];