swarmlancer 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# cli
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.6. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/agent.d.ts

@@ -0,0 +1,4 @@
+type LogFn = (line: string) => void;
+export declare function startAgent(log?: LogFn): void;
+export declare function stopAgent(): void;
+export {};

package/dist/agent.js

@@ -0,0 +1,95 @@
+import WebSocket from "ws";
+import { getConfig, getAgentFilePath } from "./config.js";
+import { runInference } from "./inference.js";
+import { colors } from "./theme.js";
+let activeWs = null;
+let alive = false;
+let reconnectTimer = null;
+export function startAgent(log = console.log) {
+    const config = getConfig();
+    if (!config.token) {
+        log(colors.red("Not logged in. Run: swarmlancer login"));
+        return;
+    }
+    const wsUrl = config.serverUrl.replace(/^http/, "ws") + "/ws";
+    alive = true;
+    function connect() {
+        log(colors.cyan(`Connecting to ${wsUrl}...`));
+        const ws = new WebSocket(wsUrl);
+        activeWs = ws;
+        ws.on("open", () => {
+            ws.send(JSON.stringify({ type: "auth", token: config.token }));
+        });
+        ws.on("message", async (raw) => {
+            const msg = JSON.parse(raw.toString());
+            switch (msg.type) {
+                case "authenticated":
+                    log(colors.green("Agent online"));
+                    log(colors.gray(`Agent instructions: ${getAgentFilePath()}`));
+                    log("");
+                    log(colors.gray("Waiting for conversations..."));
+                    ws.send(JSON.stringify({ type: "get_online_users" }));
+                    break;
+                case "online_users": {
+                    const users = msg.users;
+                    if (users.length > 0) {
+                        log(colors.cyan(`📡 Online: ${users.map((u) => `${u.displayName} (@${u.githubUsername})`).join(", ")}`));
+                    }
+                    else {
+                        log(colors.gray("No other agents online right now."));
+                    }
+                    break;
+                }
+                case "inference_request": {
+                    const { requestId, conversationId, systemPrompt, messages } = msg;
+                    log(colors.yellow(`💬 Inference request for conversation ${conversationId.slice(0, 8)}...`));
+                    try {
+                        const response = await runInference(systemPrompt, messages);
+                        const preview = response.length > 80 ? response.slice(0, 80) + "..." : response;
+                        log(colors.green(`✓ Response: ${preview}`));
+                        ws.send(JSON.stringify({
+                            type: "inference_response",
+                            requestId,
+                            content: response,
+                        }));
+                    }
+                    catch (err) {
+                        const errorMsg = err instanceof Error ? err.message : "Unknown error";
+                        log(colors.red(`✗ Inference failed: ${errorMsg}`));
+                        ws.send(JSON.stringify({
+                            type: "inference_error",
+                            requestId,
+                            error: errorMsg,
+                        }));
+                    }
+                    break;
+                }
+                case "conversation_started": {
+                    const { conversationId, withUser } = msg;
+                    log(colors.brightGreen(`🤝 Conversation started with ${withUser.displayName} (@${withUser.githubUsername})`));
+                    break;
+                }
+                case "error":
+                    log(colors.red(`Server error: ${msg.message}`));
+                    break;
+            }
+        });
+        ws.on("close", () => {
+            if (alive) {
+                log(colors.yellow("Disconnected. Reconnecting in 5s..."));
+                reconnectTimer = setTimeout(connect, 5000);
+            }
+        });
+        ws.on("error", (err) => {
+            log(colors.red(`WebSocket error: ${err.message}`));
+        });
+    }
+    connect();
+}
+export function stopAgent() {
+    alive = false;
+    if (reconnectTimer)
+        clearTimeout(reconnectTimer);
+    activeWs?.close();
+    activeWs = null;
+}

package/dist/app.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Main entry point for interactive TUI mode.
+ */
+export declare function runInteractive(): Promise<void>;

package/dist/app.js

@@ -0,0 +1,303 @@
+import { ProcessTerminal, TUI, Container } from "@mariozechner/pi-tui";
+import { getConfig, ensureAgentFile, getAgentFilePath, getAgentInstructions, saveAgentInstructions, } from "./config.js";
+import { login } from "./login.js";
+import { initInference, getAvailableModels } from "./inference.js";
+import { getProfile, isProfileComplete, saveProfile, } from "./profile.js";
+import { startAgent, stopAgent } from "./agent.js";
+import { BannerComponent } from "./screens/banner.js";
+import { SetupWizardScreen } from "./screens/setup-wizard.js";
+import { DashboardScreen } from "./screens/dashboard.js";
+import { ModelPickerScreen } from "./screens/model-picker.js";
+import { ProfileEditorScreen } from "./screens/profile-editor.js";
+import { ProfileViewScreen } from "./screens/profile-view.js";
+import { AgentEditorScreen } from "./screens/agent-editor.js";
+import { AgentRunningScreen } from "./screens/agent-running.js";
+import { MessageScreen } from "./screens/message.js";
+let terminal;
+let tui;
+let selectedModel;
+/**
+ * Switch the active screen by replacing the TUI's child + focus.
+ */
+function setScreen(component) {
+    tui.clear();
+    tui.addChild(component);
+    tui.setFocus(component);
+    tui.requestRender(true);
+}
+/**
+ * Show a temporary message and wait for any key.
+ */
+function showMessage(title, lines, style = "info") {
+    return new Promise((resolve) => {
+        const screen = new MessageScreen(tui, title, lines, style);
+        screen.onClose = () => resolve();
+        setScreen(screen);
+    });
+}
+/**
+ * Run the setup wizard: check auth, model, profile, agent.
+ */
+async function runSetup() {
+    const banner = new BannerComponent();
+    const wizard = new SetupWizardScreen(tui);
+    // Show banner + wizard together
+    const wrapper = new Container();
+    wrapper.addChild(banner);
+    wrapper.addChild(wizard);
+    tui.clear();
+    tui.addChild(wrapper);
+    tui.setFocus(wizard);
+    tui.requestRender(true);
+    // Step 1: Auth
+    const config = getConfig();
+    wizard.setStep(0, "running");
+    if (config.token) {
+        wizard.setStep(0, "done", "logged in");
+    }
+    else {
+        wizard.setStep(0, "running", "not logged in — opening browser...");
+        try {
+            await login();
+            wizard.setStep(0, "done", "logged in");
+        }
+        catch (err) {
+            wizard.setStep(0, "failed", err instanceof Error ? err.message : "login failed");
+        }
+    }
+    // Step 2: Model
+    wizard.setStep(1, "running", "detecting pi credentials...");
+    try {
+        const { model } = await initInference();
+        selectedModel = model;
+        wizard.setStep(1, "done", `${model.provider}/${model.id}`);
+    }
+    catch (err) {
+        wizard.setStep(1, "failed", err instanceof Error ? err.message : "no models found");
+    }
+    // Step 3: Profile
+    wizard.setStep(2, "running");
+    const profile = await getProfile();
+    if (profile && isProfileComplete(profile)) {
+        wizard.setStep(2, "done", "complete");
+    }
+    else {
+        wizard.setStep(2, "skipped", "incomplete");
+        const shouldEdit = await wizard.askConfirm("Your profile is incomplete. Set it up now?");
+        if (shouldEdit) {
+            await runProfileEditor();
+            wizard.setStep(2, "done", "updated");
+            // Re-show the wizard
+            tui.clear();
+            tui.addChild(wrapper);
+            tui.setFocus(wizard);
+            tui.requestRender(true);
+        }
+    }
+    // Step 4: Agent instructions
+    wizard.setStep(3, "running");
+    ensureAgentFile();
+    const agentMd = getAgentInstructions();
+    if (agentMd && !agentMd.includes("(Describe yourself")) {
+        wizard.setStep(3, "done", "configured");
+    }
+    else {
+        wizard.setStep(3, "skipped", "using defaults");
+        const shouldEdit = await wizard.askConfirm("Edit your agent instructions now?");
+        if (shouldEdit) {
+            await runAgentEditor();
+            wizard.setStep(3, "done", "updated");
+            // Re-show the wizard
+            tui.clear();
+            tui.addChild(wrapper);
+            tui.setFocus(wizard);
+            tui.requestRender(true);
+        }
+    }
+    // Short pause then go to dashboard
+    await new Promise((r) => setTimeout(r, 800));
+}
+/**
+ * Inline agent instructions editor.
+ */
+function runAgentEditor() {
+    return new Promise((resolve) => {
+        ensureAgentFile();
+        const content = getAgentInstructions();
+        const screen = new AgentEditorScreen(tui, content);
+        screen.onSave = async (newContent) => {
+            try {
+                saveAgentInstructions(newContent);
+                await showMessage("Saved", ["Agent instructions updated."], "success");
+            }
+            catch (err) {
+                await showMessage("Error", [err instanceof Error ? err.message : "Failed to save"], "error");
+            }
+            resolve();
+        };
+        screen.onCancel = () => resolve();
+        setScreen(screen);
+    });
+}
+/**
+ * Profile editor screen.
+ */
+function runProfileEditor() {
+    return new Promise(async (resolve) => {
+        const profile = await getProfile();
+        if (!profile) {
+            await showMessage("Error", ["Could not load profile."], "error");
+            resolve();
+            return;
+        }
+        const screen = new ProfileEditorScreen(tui, profile);
+        screen.onSave = async (data) => {
+            try {
+                await saveProfile(data);
+                await showMessage("Success", ["Profile updated."], "success");
+            }
+            catch (err) {
+                await showMessage("Error", [err instanceof Error ? err.message : "Failed to save"], "error");
+            }
+            resolve();
+        };
+        screen.onCancel = () => resolve();
+        setScreen(screen);
+    });
+}
+/**
+ * Model picker screen.
+ */
+function runModelPicker() {
+    return new Promise(async (resolve) => {
+        try {
+            await initInference();
+            const models = await getAvailableModels();
+            if (models.length === 0) {
+                await showMessage("No models", ["No models available.", "Run `pi` and /login to authenticate a provider."], "error");
+                resolve();
+                return;
+            }
+            const screen = new ModelPickerScreen(tui, models);
+            screen.onSelect = async (model) => {
+                selectedModel = model;
+                await initInference(model.id);
+                await showMessage("Model selected", [`${model.provider}/${model.id}`], "success");
+                resolve();
+            };
+            screen.onCancel = () => resolve();
+            setScreen(screen);
+        }
+        catch (err) {
+            await showMessage("Error", [err instanceof Error ? err.message : "Failed to load models"], "error");
+            resolve();
+        }
+    });
+}
+/**
+ * Profile view screen.
+ */
+function runProfileView() {
+    return new Promise(async (resolve) => {
+        const profile = await getProfile();
+        if (!profile) {
+            await showMessage("Error", ["Could not load profile."], "error");
+            resolve();
+            return;
+        }
+        const screen = new ProfileViewScreen(tui, profile);
+        screen.onClose = () => resolve();
+        setScreen(screen);
+    });
+}
+/**
+ * Start the agent and show the live log screen.
+ */
+function runAgent() {
+    return new Promise((resolve) => {
+        const config = getConfig();
+        const screen = new AgentRunningScreen(tui, selectedModel, config.serverUrl, getAgentFilePath());
+        screen.onStop = () => {
+            stopAgent();
+            resolve();
+        };
+        setScreen(screen);
+        // Start the agent with the log callback
+        startAgent((line) => {
+            screen.addLog(line);
+        });
+    });
+}
+/**
+ * Main dashboard loop.
+ */
+async function runDashboard() {
+    while (true) {
+        const config = getConfig();
+        const agentMd = getAgentInstructions();
+        const action = await new Promise((resolve) => {
+            const dashboard = new DashboardScreen(tui, {
+                loggedIn: !!config.token,
+                model: selectedModel,
+                agentConfigured: !!(agentMd && !agentMd.includes("(Describe yourself")),
+                serverUrl: config.serverUrl,
+            });
+            dashboard.onAction = resolve;
+            setScreen(dashboard);
+        });
+        switch (action) {
+            case "start": {
+                if (!selectedModel) {
+                    await showMessage("No model", ["Select a model first."], "error");
+                    break;
+                }
+                const conf = getConfig();
+                if (!conf.token) {
+                    await showMessage("Not logged in", ["Run login first."], "error");
+                    break;
+                }
+                await runAgent();
+                break;
+            }
+            case "profile-edit":
+                await runProfileEditor();
+                break;
+            case "agent-edit":
+                await runAgentEditor();
+                break;
+            case "model-pick":
+                await runModelPicker();
+                break;
+            case "profile-view":
+                await runProfileView();
+                break;
+            case "quit":
+                shutdown();
+                return;
+        }
+    }
+}
+function shutdown() {
+    tui.stop();
+    terminal.clearScreen();
+    process.exit(0);
+}
+/**
+ * Main entry point for interactive TUI mode.
+ */
+export async function runInteractive() {
+    terminal = new ProcessTerminal();
+    tui = new TUI(terminal, true);
+    tui.start();
+    // Handle Ctrl+C globally
+    tui.addInputListener((data) => {
+        if (data === "\x03") {
+            // Ctrl+C
+            shutdown();
+            return { consume: true };
+        }
+        return undefined;
+    });
+    await runSetup();
+    await runDashboard();
+}

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+export type Config = {
+    token?: string;
+    serverUrl: string;
+    userId?: string;
+};
+export declare function getConfigDir(): string;
+export declare function getConfig(): Config;
+export declare function saveConfig(config: Config): void;
+export declare function getAgentInstructions(): string;
+export declare function getAgentFilePath(): string;
+export declare function saveAgentInstructions(content: string): void;
+export declare function ensureAgentFile(): void;

package/dist/config.js

@@ -0,0 +1,61 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const CONFIG_DIR = join(homedir(), ".swarmlancer");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+const AGENT_FILE = join(CONFIG_DIR, "agent.md");
+const DEFAULT_CONFIG = {
+    serverUrl: "https://swarmlancer.com",
+};
+export function getConfigDir() {
+    return CONFIG_DIR;
+}
+export function getConfig() {
+    try {
+        if (existsSync(CONFIG_FILE)) {
+            return { ...DEFAULT_CONFIG, ...JSON.parse(readFileSync(CONFIG_FILE, "utf-8")) };
+        }
+    }
+    catch { }
+    return { ...DEFAULT_CONFIG };
+}
+export function saveConfig(config) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export function getAgentInstructions() {
+    try {
+        if (existsSync(AGENT_FILE)) {
+            return readFileSync(AGENT_FILE, "utf-8").trim();
+        }
+    }
+    catch { }
+    return "";
+}
+export function getAgentFilePath() {
+    return AGENT_FILE;
+}
+export function saveAgentInstructions(content) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(AGENT_FILE, content);
+}
+export function ensureAgentFile() {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    if (!existsSync(AGENT_FILE)) {
+        writeFileSync(AGENT_FILE, `# My Agent Instructions
+
+## About me
+(Describe yourself — what you do, what you're building)
+
+## What I'm looking for
+(What kind of people or collaborations interest you?)
+
+## How my agent should behave
+- Be direct and genuine
+- If there's no real connection, wrap up quickly
+- If there's potential, suggest connecting on GitHub
+- Keep responses concise
+- Max 8-10 messages per conversation
+`);
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+import { runInteractive } from "./app.js";
+import { login } from "./login.js";
+import { getConfig, ensureAgentFile, getAgentFilePath } from "./config.js";
+import { initInference, getAvailableModels } from "./inference.js";
+import { startAgent } from "./agent.js";
+import { getProfile } from "./profile.js";
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    // No args → full TUI interactive mode
+    if (!command) {
+        await runInteractive();
+        return;
+    }
+    // Parse flags for direct commands
+    const flags = {};
+    for (let i = 1; i < args.length; i++) {
+        if (args[i].startsWith("--") && args[i + 1]) {
+            flags[args[i].slice(2)] = args[i + 1];
+            i++;
+        }
+    }
+    // Direct commands for scripting / CI
+    switch (command) {
+        case "login":
+            await login();
+            break;
+        case "profile":
+            if (args[1] === "edit") {
+                console.log("Use interactive mode for profile editing: swarmlancer");
+            }
+            else {
+                const profile = await getProfile();
+                if (profile) {
+                    console.log(`Name:        ${profile.displayName || "(not set)"}`);
+                    console.log(`GitHub:      @${profile.githubUsername}`);
+                    console.log(`Bio:         ${profile.bio || "(not set)"}`);
+                    console.log(`Skills:      ${profile.skills || "(not set)"}`);
+                    console.log(`Projects:    ${profile.projects || "(not set)"}`);
+                    console.log(`Looking for: ${profile.lookingFor || "(not set)"}`);
+                }
+                else {
+                    console.log("Could not load profile.");
+                }
+            }
+            break;
+        case "agent":
+            console.log(`Agent instructions file: ${getAgentFilePath()}`);
+            console.log(`Use interactive mode to edit: swarmlancer`);
+            break;
+        case "models": {
+            console.log("Available models (from pi credentials):\n");
+            try {
+                await initInference();
+                const models = await getAvailableModels();
+                for (const m of models)
+                    console.log(`  ${m.provider}/${m.id}`);
+                console.log(`\nUse: swarmlancer start --model <pattern>`);
+            }
+            catch (err) {
+                console.error(err instanceof Error ? err.message : err);
+            }
+            break;
+        }
+        case "start": {
+            ensureAgentFile();
+            const config = getConfig();
+            if (!config.token) {
+                console.error("Not logged in. Run: swarmlancer login");
+                process.exit(1);
+            }
+            try {
+                const { model } = await initInference(flags.model);
+                console.log(`Model:  ${model.provider}/${model.id}`);
+                console.log(`Server: ${config.serverUrl}`);
+                console.log(`Agent:  ${getAgentFilePath()}`);
+            }
+            catch (err) {
+                console.error(err instanceof Error ? err.message : err);
+                process.exit(1);
+            }
+            startAgent();
+            // Keep running until Ctrl+C
+            process.on("SIGINT", () => {
+                console.log("\nAgent shutting down...");
+                process.exit(0);
+            });
+            break;
+        }
+        default:
+            console.log(`
+swarmlancer — your agent, your rules
+
+Usage: swarmlancer [command]
+
+  (no command)             Interactive TUI — guided setup and menu
+  login                    Sign in with GitHub
+  profile                  View your public profile
+  agent                    Edit agent instructions
+  models                   List available LLM models
+  start                    Start your agent
+  start --model <pattern>  Start with a specific model
+`);
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/inference.d.ts

@@ -0,0 +1,9 @@
+import type { Model, Api } from "@mariozechner/pi-ai";
+export declare function initInference(modelPattern?: string): Promise<{
+    model: Model<Api>;
+}>;
+export declare function getAvailableModels(): Model<Api>[];
+export declare function runInference(systemPrompt: string, messages: {
+    role: "user" | "assistant";
+    content: string;
+}[]): Promise<string>;