skillett 0.1.0

package/dist/lib/api.d.ts

@@ -0,0 +1,25 @@
+export declare function getDashboardUrl(): string;
+export declare function skillettFetch(path: string, apiKey: string, options?: RequestInit): Promise<Response>;
+export declare function validateKey(apiKey: string): Promise<boolean>;
+export interface SkillSummary {
+    name: string;
+    display_name: string;
+    description: string | null;
+    category: string | null;
+    integration: string | null;
+}
+export declare function listSkills(apiKey: string): Promise<SkillSummary[]>;
+export interface SkillDownload {
+    slug: string;
+    files: {
+        file_path: string;
+        content: string;
+    }[];
+}
+export declare function downloadSkill(apiKey: string, name: string): Promise<SkillDownload>;
+export interface WhoamiResponse {
+    id: string;
+    email: string | null;
+    display_name: string | null;
+}
+export declare function whoami(apiKey: string): Promise<WhoamiResponse>;

package/dist/lib/api.js

@@ -0,0 +1,50 @@
+const DEFAULT_BASE = "https://api.skillett.dev";
+const DEFAULT_DASHBOARD = "https://app.skillett.dev";
+function getBaseUrl() {
+    return process.env.SKILLETT_API_URL || DEFAULT_BASE;
+}
+export function getDashboardUrl() {
+    // If using local API, point to local dashboard
+    const apiUrl = getBaseUrl();
+    if (apiUrl.includes("localhost") || apiUrl.includes("127.0.0.1")) {
+        return "http://localhost:5173";
+    }
+    return DEFAULT_DASHBOARD;
+}
+export async function skillettFetch(path, apiKey, options = {}) {
+    return fetch(`${getBaseUrl()}${path}`, {
+        ...options,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+            ...options.headers,
+        },
+    });
+}
+export async function validateKey(apiKey) {
+    try {
+        const res = await skillettFetch("/v1/skills", apiKey);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function listSkills(apiKey) {
+    const res = await skillettFetch("/v1", apiKey);
+    if (!res.ok)
+        throw new Error(`Failed to list skills: ${res.status}`);
+    return res.json();
+}
+export async function downloadSkill(apiKey, name) {
+    const res = await skillettFetch(`/v1/${name}/download`, apiKey);
+    if (!res.ok)
+        throw new Error(`Failed to download skill: ${res.status}`);
+    return res.json();
+}
+export async function whoami(apiKey) {
+    const res = await skillettFetch("/auth/me", apiKey);
+    if (!res.ok)
+        throw new Error(`Failed to get user info: ${res.status}`);
+    return res.json();
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Load all SKILLETT_* vars from the project's .env into process.env.
+ * Call this early so the API client picks up SKILLETT_API_URL.
+ */
+export declare function loadEnv(): void;
+export declare function loadApiKey(): string | null;
+export declare function saveApiKey(key: string): void;
+export declare function checkGitignore(): boolean;
+export type Platform = "claude" | "cursor" | "windsurf" | "generic";
+export declare function detectPlatform(): {
+    platform: Platform;
+    label: string;
+} | null;
+export declare function getPlatformLabel(platform: Platform): string;
+export declare function loadPlatform(): Platform | null;
+export declare function savePlatform(platform: Platform): void;
+/** Get the directory where skill docs should be written for this platform */
+export declare function getSkillDocsPath(platform: Platform, slug: string): string;
+/** Get the path for the core skill pointer */
+export declare function getCoreSkillPath(platform: Platform): string;

package/dist/lib/config.js

@@ -0,0 +1,115 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+const ENV_FILE = resolve(process.cwd(), ".env");
+/**
+ * Load all SKILLETT_* vars from the project's .env into process.env.
+ * Call this early so the API client picks up SKILLETT_API_URL.
+ */
+export function loadEnv() {
+    if (!existsSync(ENV_FILE))
+        return;
+    const content = readFileSync(ENV_FILE, "utf8");
+    for (const line of content.split("\n")) {
+        const match = line.match(/^(SKILLETT_\w+)=(.+)$/);
+        if (match && !process.env[match[1]]) {
+            process.env[match[1]] = match[2].trim();
+        }
+    }
+}
+export function loadApiKey() {
+    if (!existsSync(ENV_FILE))
+        return null;
+    const content = readFileSync(ENV_FILE, "utf8");
+    const match = content.match(/^SKILLETT_API_KEY=(.+)$/m);
+    return match ? match[1].trim() : null;
+}
+export function saveApiKey(key) {
+    if (existsSync(ENV_FILE)) {
+        let content = readFileSync(ENV_FILE, "utf8");
+        if (content.match(/^SKILLETT_API_KEY=/m)) {
+            content = content.replace(/^SKILLETT_API_KEY=.*/m, `SKILLETT_API_KEY=${key}`);
+        }
+        else {
+            content = content.trimEnd() + `\nSKILLETT_API_KEY=${key}\n`;
+        }
+        writeFileSync(ENV_FILE, content);
+    }
+    else {
+        writeFileSync(ENV_FILE, `SKILLETT_API_KEY=${key}\n`);
+    }
+}
+export function checkGitignore() {
+    const gitignorePath = resolve(process.cwd(), ".gitignore");
+    if (!existsSync(gitignorePath))
+        return false;
+    const content = readFileSync(gitignorePath, "utf8");
+    return content.split("\n").some((line) => line.trim() === ".env" || line.trim() === ".env*");
+}
+const PLATFORM_MARKERS = [
+    { platform: "claude", dir: ".claude", label: "Claude Code" },
+    { platform: "cursor", dir: ".cursor", label: "Cursor" },
+    { platform: "windsurf", dir: ".windsurf", label: "Windsurf" },
+];
+export function detectPlatform() {
+    const cwd = process.cwd();
+    for (const marker of PLATFORM_MARKERS) {
+        if (existsSync(resolve(cwd, marker.dir))) {
+            return { platform: marker.platform, label: marker.label };
+        }
+    }
+    return null;
+}
+export function getPlatformLabel(platform) {
+    const found = PLATFORM_MARKERS.find((m) => m.platform === platform);
+    return found?.label || "Generic";
+}
+export function loadPlatform() {
+    if (!existsSync(ENV_FILE))
+        return null;
+    const content = readFileSync(ENV_FILE, "utf8");
+    const match = content.match(/^SKILLETT_PLATFORM=(.+)$/m);
+    return match ? match[1].trim() : null;
+}
+export function savePlatform(platform) {
+    if (existsSync(ENV_FILE)) {
+        let content = readFileSync(ENV_FILE, "utf8");
+        if (content.match(/^SKILLETT_PLATFORM=/m)) {
+            content = content.replace(/^SKILLETT_PLATFORM=.*/m, `SKILLETT_PLATFORM=${platform}`);
+        }
+        else {
+            content = content.trimEnd() + `\nSKILLETT_PLATFORM=${platform}\n`;
+        }
+        writeFileSync(ENV_FILE, content);
+    }
+    else {
+        writeFileSync(ENV_FILE, `SKILLETT_PLATFORM=${platform}\n`);
+    }
+}
+/** Get the directory where skill docs should be written for this platform */
+export function getSkillDocsPath(platform, slug) {
+    const cwd = process.cwd();
+    switch (platform) {
+        case "claude":
+            return resolve(cwd, ".claude", "skills", `skillett-${slug}`);
+        case "cursor":
+            return resolve(cwd, ".cursor", "rules", `skillett-${slug}`);
+        case "windsurf":
+            return resolve(cwd, ".windsurf", "rules", `skillett-${slug}`);
+        default:
+            return resolve(cwd, ".skillett", "skills", slug);
+    }
+}
+/** Get the path for the core skill pointer */
+export function getCoreSkillPath(platform) {
+    const cwd = process.cwd();
+    switch (platform) {
+        case "claude":
+            return resolve(cwd, ".claude", "skills", "skillett");
+        case "cursor":
+            return resolve(cwd, ".cursor", "rules", "skillett");
+        case "windsurf":
+            return resolve(cwd, ".windsurf", "rules", "skillett");
+        default:
+            return resolve(cwd, ".skillett", "skills", "skillett");
+    }
+}

package/dist/lib/device-auth.d.ts

@@ -0,0 +1,21 @@
+export interface DeviceCodeResponse {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    expires_in: number;
+    interval: number;
+}
+export interface DeviceTokenResponse {
+    status: "pending" | "complete" | "expired";
+    error?: string;
+    user?: {
+        email: string | null;
+        display_name: string | null;
+    };
+    api_keys_url?: string;
+}
+export declare function requestDeviceCode(): Promise<DeviceCodeResponse>;
+export declare function pollForToken(deviceCode: string, options?: {
+    interval?: number;
+    timeout?: number;
+}): Promise<DeviceTokenResponse>;

package/dist/lib/device-auth.js

@@ -0,0 +1,38 @@
+const DEFAULT_INTERVAL = 5000; // 5 seconds
+const DEFAULT_TIMEOUT = 900000; // 15 minutes
+function getBaseUrl() {
+    return process.env.SKILLETT_API_URL || "https://api.skillett.dev";
+}
+export async function requestDeviceCode() {
+    const res = await fetch(`${getBaseUrl()}/auth/device/code`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to request device code: ${res.status}`);
+    }
+    return res.json();
+}
+export async function pollForToken(deviceCode, options = {}) {
+    const interval = options.interval || DEFAULT_INTERVAL;
+    const timeout = options.timeout || DEFAULT_TIMEOUT;
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+        const res = await fetch(`${getBaseUrl()}/auth/device/token`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ device_code: deviceCode }),
+        });
+        if (!res.ok) {
+            throw new Error(`Device auth polling failed: ${res.status}`);
+        }
+        const data = await res.json();
+        if (data.status === "complete")
+            return data;
+        if (data.status === "expired")
+            throw new Error("Device code expired. Run `skillett login` again.");
+        // Wait before next poll
+        await new Promise((r) => setTimeout(r, interval));
+    }
+    throw new Error("Login timed out. Run `skillett login` again.");
+}

package/dist/lib/paths.d.ts

@@ -0,0 +1,4 @@
+export declare function getSkillsDir(): string;
+export declare function getSkillPath(name: string): string;
+export declare function skillExists(name: string): boolean;
+export declare function ensureSkillsDir(): void;

package/dist/lib/paths.js

@@ -0,0 +1,17 @@
+import { resolve } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+export function getSkillsDir() {
+    return resolve(process.cwd(), ".claude", "skills");
+}
+export function getSkillPath(name) {
+    return resolve(getSkillsDir(), name);
+}
+export function skillExists(name) {
+    return existsSync(getSkillPath(name));
+}
+export function ensureSkillsDir() {
+    const dir = getSkillsDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "skillett",
+  "version": "0.1.0",
+  "description": "Skillett CLI — Agent Skills Platform",
+  "type": "module",
+  "bin": {
+    "skillett": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "dotenv": "^16.5.0",
+    "open": "^10.2.0",
+    "ora": "^8.2.0",
+    "pg": "^8.20.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.0",
+    "@types/pg": "^8.20.0",
+    "tsx": "^4.19.4",
+    "typescript": "~5.9.3"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ]
+}