skillett 0.1.0

package/dist/commands/add.d.ts

@@ -0,0 +1 @@
+export declare function add(name: string): Promise<void>;

package/dist/commands/add.js

@@ -0,0 +1,39 @@
+import { writeFileSync, mkdirSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import chalk from "chalk";
+import ora from "ora";
+import { loadApiKey } from "../lib/config.js";
+import { downloadSkill } from "../lib/api.js";
+import { ensureSkillsDir, getSkillPath, skillExists } from "../lib/paths.js";
+export async function add(name) {
+    const apiKey = loadApiKey();
+    if (!apiKey) {
+        console.log(chalk.red("Not set up. Run: npx skillett setup"));
+        process.exit(1);
+    }
+    const folderName = `skillett-${name}`;
+    if (skillExists(folderName)) {
+        console.log(chalk.yellow(`Skill "${name}" is already installed. Remove it first to reinstall.`));
+        process.exit(1);
+    }
+    const spinner = ora(`Downloading ${name} skill…`).start();
+    try {
+        const { files } = await downloadSkill(apiKey, name);
+        ensureSkillsDir();
+        const skillDir = getSkillPath(folderName);
+        for (const file of files) {
+            const targetPath = resolve(skillDir, file.file_path);
+            mkdirSync(dirname(targetPath), { recursive: true });
+            writeFileSync(targetPath, file.content, "utf8");
+        }
+        spinner.succeed(`Installed ${chalk.bold(name)} skill (${files.length} files)`);
+        console.log(chalk.gray(`  → .claude/skills/${folderName}/`));
+        console.log();
+        console.log("Your agent can now use it.");
+    }
+    catch (err) {
+        spinner.fail(`Failed to install ${name}`);
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+}

package/dist/commands/connect.d.ts

@@ -0,0 +1 @@
+export declare function connect(integration: string): Promise<void>;

package/dist/commands/connect.js

@@ -0,0 +1,81 @@
+import chalk from "chalk";
+import open from "open";
+import ora from "ora";
+import { loadApiKey } from "../lib/config.js";
+import { skillettFetch } from "../lib/api.js";
+const POLL_INTERVAL = 3000; // 3 seconds
+const POLL_TIMEOUT = 300000; // 5 minutes
+export async function connect(integration) {
+    const apiKey = loadApiKey();
+    if (!apiKey) {
+        console.error(JSON.stringify({ error: "not_authenticated", message: "Run `skillett login` first." }));
+        process.exit(1);
+    }
+    const isTTY = process.stdout.isTTY;
+    // Initiate connection via API
+    const spinner = isTTY ? ora(`  Connecting ${integration}…`).start() : null;
+    const res = await skillettFetch("/v1/connect", apiKey, {
+        method: "POST",
+        body: JSON.stringify({ integration }),
+    });
+    if (!res.ok) {
+        spinner?.fail(`  Failed to connect ${integration}`);
+        const body = await res.json().catch(() => ({ error: "request_failed" }));
+        console.log(JSON.stringify(body, null, 2));
+        process.exit(1);
+    }
+    const data = await res.json();
+    // Already connected
+    if (data.status === "already_connected") {
+        spinner?.succeed(`  ${integration} is already connected`);
+        if (!isTTY) {
+            console.log(JSON.stringify({ status: "connected", integration }));
+        }
+        return;
+    }
+    // OAuth flow — open browser and poll
+    if (data.oauth_url && data.connection_id) {
+        spinner?.stop();
+        if (isTTY) {
+            console.log(chalk.bold(`  Complete the ${integration} OAuth flow in your browser.`));
+            console.log();
+        }
+        try {
+            await open(data.oauth_url);
+        }
+        catch {
+            if (isTTY) {
+                console.log(chalk.cyan(`  ${data.oauth_url}`));
+                console.log();
+            }
+        }
+        const pollSpinner = isTTY ? ora("  Waiting for authorization…").start() : null;
+        const deadline = Date.now() + POLL_TIMEOUT;
+        while (Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, POLL_INTERVAL));
+            const statusRes = await skillettFetch(`/v1/connect/${data.connection_id}`, apiKey);
+            if (!statusRes.ok)
+                continue;
+            const statusData = await statusRes.json();
+            if (statusData.status === "connected") {
+                pollSpinner?.succeed(`  ${integration} connected`);
+                if (!isTTY) {
+                    console.log(JSON.stringify({ status: "connected", integration }));
+                }
+                return;
+            }
+            if (statusData.status === "error") {
+                pollSpinner?.fail(`  ${integration} connection failed`);
+                if (!isTTY) {
+                    console.log(JSON.stringify({ status: "error", integration }));
+                }
+                process.exit(1);
+            }
+        }
+        pollSpinner?.fail("  Connection timed out");
+        if (isTTY) {
+            console.log(chalk.gray("  Run `skillett skills` to check the status."));
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/disconnect.d.ts

@@ -0,0 +1 @@
+export declare function disconnect(integration: string): Promise<void>;

package/dist/commands/disconnect.js

@@ -0,0 +1,43 @@
+import chalk from "chalk";
+import ora from "ora";
+import { loadApiKey } from "../lib/config.js";
+import { skillettFetch } from "../lib/api.js";
+export async function disconnect(integration) {
+    const apiKey = loadApiKey();
+    if (!apiKey) {
+        console.error(JSON.stringify({ error: "not_authenticated", message: "Run `skillett login` first." }));
+        process.exit(1);
+    }
+    const isTTY = process.stdout.isTTY;
+    const spinner = isTTY ? ora(`  Disconnecting ${integration}…`).start() : null;
+    // Get the connection to find its ID
+    const listRes = await skillettFetch("/connections", apiKey);
+    if (!listRes.ok) {
+        spinner?.fail("  Failed to fetch connections");
+        process.exit(1);
+    }
+    const connections = await listRes.json();
+    const conn = connections.find((c) => c.integration?.slug === integration && c.status !== "revoked");
+    if (!conn) {
+        spinner?.fail(`  No active connection found for ${integration}`);
+        if (isTTY) {
+            console.log(chalk.gray("  Run `skillett skills` to see connected integrations."));
+        }
+        process.exit(1);
+    }
+    const deleteRes = await skillettFetch(`/connections/${conn.id}`, apiKey, {
+        method: "DELETE",
+    });
+    if (deleteRes.ok || deleteRes.status === 204) {
+        spinner?.succeed(`  Disconnected ${integration}`);
+        if (!isTTY) {
+            console.log(JSON.stringify({ status: "disconnected", integration }));
+        }
+    }
+    else {
+        spinner?.fail(`  Failed to disconnect ${integration}`);
+        const body = await deleteRes.json().catch(() => ({}));
+        console.log(JSON.stringify(body, null, 2));
+        process.exit(1);
+    }
+}

package/dist/commands/list.d.ts

@@ -0,0 +1 @@
+export declare function list(): Promise<void>;

package/dist/commands/list.js

@@ -0,0 +1,43 @@
+import chalk from "chalk";
+import ora from "ora";
+import { loadApiKey } from "../lib/config.js";
+import { listSkills } from "../lib/api.js";
+export async function list() {
+    const apiKey = loadApiKey();
+    if (!apiKey) {
+        console.log(chalk.red("Not logged in. Run: npx skillett login"));
+        process.exit(1);
+    }
+    const spinner = ora("Fetching skills…").start();
+    try {
+        const skills = await listSkills(apiKey);
+        spinner.stop();
+        if (skills.length === 0) {
+            console.log(chalk.yellow("No skills available. Connect an integration first."));
+            return;
+        }
+        console.log();
+        console.log(chalk.bold(`Available skills (${skills.length}):`));
+        console.log();
+        // Group by integration
+        const grouped = new Map();
+        for (const skill of skills) {
+            const key = skill.integration || "other";
+            if (!grouped.has(key))
+                grouped.set(key, []);
+            grouped.get(key).push(skill);
+        }
+        for (const [integration, integrationSkills] of grouped) {
+            console.log(chalk.cyan.bold(`  ${integration}`));
+            for (const skill of integrationSkills) {
+                console.log(`    ${chalk.white(skill.name.padEnd(25))} ${chalk.gray(skill.description || "")}`);
+            }
+            console.log();
+        }
+    }
+    catch (err) {
+        spinner.fail("Failed to fetch skills");
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,3 @@
+export declare function login(options?: {
+    key?: string;
+}): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,172 @@
+import { createInterface } from "node:readline";
+import { writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import chalk from "chalk";
+import open from "open";
+import ora from "ora";
+import { saveApiKey, checkGitignore, detectPlatform, savePlatform, getCoreSkillPath, getPlatformLabel, } from "../lib/config.js";
+import { validateKey, getDashboardUrl } from "../lib/api.js";
+import { requestDeviceCode, pollForToken } from "../lib/device-auth.js";
+// Note: ensureSkillsDir from paths.ts is no longer used — platform-aware paths are in config.ts
+function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function promptPlatform() {
+    console.log();
+    console.log("  Which agent platform are you using?");
+    console.log("    1. Claude Code");
+    console.log("    2. Cursor");
+    console.log("    3. Windsurf");
+    console.log("    4. Other");
+    console.log();
+    const answer = await prompt("  Enter number (1-4): ");
+    switch (answer) {
+        case "1": return "claude";
+        case "2": return "cursor";
+        case "3": return "windsurf";
+        default: return "generic";
+    }
+}
+const CORE_SKILL_MD = `---
+name: skillett
+description: Skillett agent skills platform — run \`skillett help\` to discover available commands.
+user-invocable: false
+---
+
+# Skillett
+
+Skillett is installed. Run CLI commands to discover and execute agent skills.
+
+    skillett help          # see all commands
+    skillett skills        # list available integrations
+    skillett run ...       # execute an endpoint
+`;
+export async function login(options = {}) {
+    console.log();
+    console.log(chalk.bold("  Skillett Login"));
+    console.log();
+    let key = options.key || process.env.SKILLETT_API_KEY;
+    if (key) {
+        // Direct key mode (--key flag or env var)
+        if (!key.startsWith("sk_")) {
+            console.log(chalk.red("  Invalid key format. Keys start with sk_"));
+            process.exit(1);
+        }
+        const spinner = ora("  Validating key…").start();
+        const valid = await validateKey(key);
+        if (!valid) {
+            spinner.fail("  Invalid API key");
+            process.exit(1);
+        }
+        spinner.succeed("  Key validated");
+    }
+    else {
+        // Device authorization flow
+        const spinner = ora("  Requesting device code…").start();
+        let deviceResponse;
+        try {
+            deviceResponse = await requestDeviceCode();
+        }
+        catch (err) {
+            spinner.fail("  Failed to start login");
+            console.error(chalk.red(`  ${err instanceof Error ? err.message : err}`));
+            process.exit(1);
+        }
+        spinner.stop();
+        console.log(chalk.bold("  Open this URL and enter the code below:"));
+        console.log();
+        console.log(chalk.cyan(`  ${deviceResponse.verification_uri}`));
+        console.log();
+        console.log(chalk.bold(`  Code: ${chalk.yellow(deviceResponse.user_code)}`));
+        console.log();
+        // Try to open browser with code pre-filled
+        try {
+            const url = `${deviceResponse.verification_uri}?code=${deviceResponse.user_code}`;
+            await open(url);
+        }
+        catch {
+            // Non-fatal
+        }
+        const pollSpinner = ora("  Waiting for authorization…").start();
+        let tokenResponse;
+        try {
+            tokenResponse = await pollForToken(deviceResponse.device_code, {
+                interval: (deviceResponse.interval || 5) * 1000,
+            });
+        }
+        catch (err) {
+            pollSpinner.fail("  Authorization failed");
+            console.error(chalk.red(`  ${err instanceof Error ? err.message : err}`));
+            process.exit(1);
+        }
+        pollSpinner.succeed(`  Authorized${tokenResponse.user?.email ? ` as ${tokenResponse.user.email}` : ""}`);
+        console.log();
+        // Redirect to API keys page
+        const dashboardUrl = getDashboardUrl();
+        const apiKeysUrl = `${dashboardUrl}/api-keys`;
+        console.log(chalk.bold("  Now grab your API key from the dashboard:"));
+        console.log(chalk.cyan(`  ${apiKeysUrl}`));
+        console.log();
+        try {
+            await open(apiKeysUrl);
+        }
+        catch {
+            // Non-fatal
+        }
+        key = await prompt("  Paste your API key: ");
+        if (!key.startsWith("sk_")) {
+            console.log(chalk.red("  Invalid key format. Keys start with sk_"));
+            process.exit(1);
+        }
+        const validateSpinner = ora("  Validating key…").start();
+        const valid = await validateKey(key);
+        if (!valid) {
+            validateSpinner.fail("  Invalid API key");
+            process.exit(1);
+        }
+        validateSpinner.succeed("  Key validated");
+    }
+    // Save to .env
+    saveApiKey(key);
+    console.log(chalk.green("  Saved to .env"));
+    // Check .gitignore
+    if (!checkGitignore()) {
+        console.log(chalk.yellow("  Warning: .env is not in your .gitignore"));
+    }
+    // Detect platform
+    let platform = "generic";
+    const detected = detectPlatform();
+    if (detected) {
+        const answer = await prompt(`  Detected ${chalk.cyan(detected.label)}. Correct? (Y/n) `);
+        if (answer.toLowerCase() !== "n") {
+            platform = detected.platform;
+        }
+        else {
+            platform = await promptPlatform();
+        }
+    }
+    else {
+        platform = await promptPlatform();
+    }
+    savePlatform(platform);
+    console.log(chalk.green(`  Platform: ${getPlatformLabel(platform)}`));
+    // Install core skill pointer
+    const skillDir = getCoreSkillPath(platform);
+    if (!existsSync(skillDir)) {
+        mkdirSync(skillDir, { recursive: true });
+    }
+    writeFileSync(resolve(skillDir, "SKILL.md"), CORE_SKILL_MD);
+    console.log(chalk.green(`  Installed core skill to ${skillDir.replace(process.cwd(), ".")}/`));
+    console.log();
+    console.log(chalk.bold("  You're all set! Try:"));
+    console.log("    skillett skills       # see available integrations");
+    console.log("    skillett connect ...  # connect an integration");
+    console.log("    skillett run ...      # execute an endpoint");
+    console.log();
+}

package/dist/commands/pull.d.ts

@@ -0,0 +1,3 @@
+export declare function pull(slug: string, options?: {
+    path?: string;
+}): Promise<void>;

package/dist/commands/pull.js

@@ -0,0 +1,46 @@
+import { mkdirSync, writeFileSync, existsSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import ora from "ora";
+import { loadApiKey, loadPlatform, getSkillDocsPath } from "../lib/config.js";
+import { skillettFetch } from "../lib/api.js";
+export async function pull(slug, options = {}) {
+    const apiKey = loadApiKey();
+    if (!apiKey) {
+        console.error(JSON.stringify({ error: "not_authenticated", message: "Run `skillett login` first." }));
+        process.exit(1);
+    }
+    const platform = loadPlatform() || "generic";
+    const targetDir = options.path || getSkillDocsPath(platform, slug);
+    const isTTY = process.stdout.isTTY;
+    const spinner = isTTY ? ora(`  Pulling ${slug} skill docs…`).start() : null;
+    // Download skill files from API
+    const res = await skillettFetch(`/v1/${slug}/download`, apiKey);
+    if (!res.ok) {
+        spinner?.fail(`  Failed to pull ${slug}`);
+        const body = await res.json().catch(() => ({ error: "request_failed" }));
+        console.error(JSON.stringify(body, null, 2));
+        process.exit(1);
+    }
+    const data = await res.json();
+    if (!data.files?.length) {
+        spinner?.fail(`  No files found for ${slug}`);
+        process.exit(1);
+    }
+    // Write files to target directory
+    for (const file of data.files) {
+        const filePath = resolve(targetDir, file.file_path);
+        const dir = dirname(filePath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(filePath, file.content);
+    }
+    spinner?.succeed(`  Pulled ${data.files.length} files to ${targetDir.replace(process.cwd(), ".")}`);
+    if (!isTTY) {
+        console.log(JSON.stringify({
+            slug,
+            files: data.files.length,
+            path: targetDir,
+        }));
+    }
+}

package/dist/commands/remove.d.ts

@@ -0,0 +1 @@
+export declare function remove(name: string): Promise<void>;

package/dist/commands/remove.js

@@ -0,0 +1,12 @@
+import { rmSync } from "node:fs";
+import chalk from "chalk";
+import { getSkillPath, skillExists } from "../lib/paths.js";
+export async function remove(name) {
+    const folderName = `skillett-${name}`;
+    if (!skillExists(folderName)) {
+        console.log(chalk.red(`Skill "${name}" is not installed.`));
+        process.exit(1);
+    }
+    rmSync(getSkillPath(folderName), { recursive: true });
+    console.log(chalk.green(`Removed "${name}" skill.`));
+}

package/dist/commands/run.d.ts

@@ -0,0 +1 @@
+export declare function run(integration: string, endpoint: string, extraArgs: string[]): Promise<void>;

package/dist/commands/run.js

@@ -0,0 +1,85 @@
+import ora from "ora";
+import { loadApiKey } from "../lib/config.js";
+import { skillettFetch } from "../lib/api.js";
+/**
+ * Parse CLI flags into a params object.
+ * Handles: --key value, --flag (boolean true), and JSON string mode.
+ */
+function parseParams(args) {
+    // JSON mode: single positional argument starting with {
+    if (args.length === 1 && args[0].startsWith("{")) {
+        try {
+            return JSON.parse(args[0]);
+        }
+        catch {
+            console.error(JSON.stringify({ error: "invalid_json", message: "Failed to parse JSON parameter." }));
+            process.exit(1);
+        }
+    }
+    const params = {};
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg.startsWith("--")) {
+            const key = arg.slice(2);
+            const next = args[i + 1];
+            // Boolean flag (no value or next is another flag)
+            if (!next || next.startsWith("--")) {
+                params[key] = true;
+                i++;
+                continue;
+            }
+            // Numeric value
+            if (/^-?\d+(\.\d+)?$/.test(next)) {
+                params[key] = Number(next);
+                i += 2;
+                continue;
+            }
+            // Comma-separated array
+            if (next.includes(",") && !next.startsWith("{")) {
+                params[key] = next.split(",").map((s) => s.trim());
+                i += 2;
+                continue;
+            }
+            // String value
+            params[key] = next;
+            i += 2;
+            continue;
+        }
+        i++;
+    }
+    return params;
+}
+export async function run(integration, endpoint, extraArgs) {
+    const apiKey = loadApiKey();
+    if (!apiKey) {
+        console.error(JSON.stringify({ error: "not_authenticated", message: "Run `skillett login` first." }));
+        process.exit(1);
+    }
+    const params = parseParams(extraArgs);
+    const isTTY = process.stdout.isTTY;
+    const spinner = isTTY ? ora({ text: "  Executing…", stream: process.stderr }).start() : null;
+    try {
+        const res = await skillettFetch(`/v1/${integration}/${endpoint}`, apiKey, {
+            method: "POST",
+            body: JSON.stringify({ params }),
+        });
+        spinner?.stop();
+        const data = await res.json();
+        // Wrap in consistent output shape
+        const output = res.ok
+            ? { status: res.status, data }
+            : { status: res.status, ...data };
+        console.log(JSON.stringify(output, null, 2));
+        process.exit(res.ok ? 0 : 1);
+    }
+    catch (err) {
+        spinner?.stop();
+        console.error(JSON.stringify({
+            error: "network_error",
+            message: err instanceof Error ? err.message : "Request failed",
+            status: 0,
+        }));
+        process.exit(2);
+    }
+}

package/dist/commands/seed.d.ts

@@ -0,0 +1,3 @@
+export declare function seed(skillDir: string, opts: {
+    databaseUrl?: string;
+}): Promise<void>;