swarmlancer-cli 0.2.0

package/dist/app.js

@@ -0,0 +1,496 @@
+import { ProcessTerminal, TUI, Container } from "@mariozechner/pi-tui";
+import { getConfig, getAgents, getAgent, saveAgent, deleteAgent, createAgent, migrateLegacyAgent, } from "./config.js";
+import { login } from "./login.js";
+import { initInference, getAvailableModels, setAgentInstructions } from "./inference.js";
+import { startAgent, stopAgent, sendToServer } from "./agent.js";
+import { colors } from "./theme.js";
+import { BannerComponent } from "./screens/banner.js";
+import { SetupWizardScreen } from "./screens/setup-wizard.js";
+import { DashboardScreen } from "./screens/dashboard.js";
+import { AgentListScreen } from "./screens/agent-list.js";
+import { AgentConfigScreen } from "./screens/agent-config.js";
+import { AgentPickerScreen } from "./screens/agent-picker.js";
+import { AgentEditorScreen } from "./screens/agent-editor.js";
+import { AgentRunningScreen } from "./screens/agent-running.js";
+import { SettingsScreen } from "./screens/settings.js";
+import { DiscoverySettingsScreen } from "./screens/discovery-settings.js";
+import { ModelPickerScreen } from "./screens/model-picker.js";
+import { NameEditorScreen } from "./screens/name-editor.js";
+import { SessionGoalScreen } from "./screens/session-goal.js";
+import { MessageScreen } from "./screens/message.js";
+import { screenProfiles } from "./screening.js";
+let terminal;
+let tui;
+let detectedModel;
+/**
+ * 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, agents.
+ */
+async function runSetup() {
+    // Migrate legacy single-agent setup
+    migrateLegacyAgent();
+    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();
+        detectedModel = 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: Agents
+    wizard.setStep(2, "running");
+    const agents = getAgents();
+    if (agents.length > 0) {
+        wizard.setStep(2, "done", `${agents.length} agent${agents.length === 1 ? "" : "s"}`);
+    }
+    else {
+        wizard.setStep(2, "skipped", "no agents yet");
+        const shouldCreate = await wizard.askConfirm("You have no agents. Create one now?");
+        if (shouldCreate) {
+            const name = await askName("New Agent Name", "Give your first agent a name.");
+            if (name) {
+                createAgent(name);
+                wizard.setStep(2, "done", "1 agent created");
+            }
+            else {
+                wizard.setStep(2, "skipped", "skipped");
+            }
+            // 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));
+}
+// ── Sub-screens that return promises ──────────────────────
+/**
+ * Ask the user for a name via the NameEditorScreen.
+ */
+function askName(title, subtitle, current = "") {
+    return new Promise((resolve) => {
+        const screen = new NameEditorScreen(tui, current, title, subtitle);
+        screen.onSave = (name) => resolve(name);
+        screen.onCancel = () => resolve(null);
+        setScreen(screen);
+    });
+}
+/**
+ * Inline agent instructions editor.
+ */
+function editInstructions(agent) {
+    return new Promise((resolve) => {
+        const screen = new AgentEditorScreen(tui, agent.instructions);
+        screen.onSave = async (newContent) => {
+            try {
+                agent.instructions = newContent;
+                saveAgent(agent);
+                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);
+    });
+}
+/**
+ * Agent limits settings screen.
+ */
+function editLimits(agent) {
+    return new Promise((resolve) => {
+        const screen = new SettingsScreen(tui, agent.limits);
+        screen.onSave = async (newLimits) => {
+            try {
+                agent.limits = newLimits;
+                saveAgent(agent);
+                await showMessage("Saved", ["Agent limits updated."], "success");
+            }
+            catch (err) {
+                await showMessage("Error", [err instanceof Error ? err.message : "Failed to save"], "error");
+            }
+            resolve();
+        };
+        screen.onCancel = () => resolve();
+        setScreen(screen);
+    });
+}
+/**
+ * Discovery settings screen.
+ */
+function editDiscovery(agent) {
+    return new Promise((resolve) => {
+        const screen = new DiscoverySettingsScreen(tui, agent.discovery);
+        screen.onSave = async (newSettings) => {
+            try {
+                agent.discovery = newSettings;
+                saveAgent(agent);
+                await showMessage("Saved", ["Discovery settings 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 — saves the model pattern to the agent.
+ */
+function editModel(agent) {
+    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) => {
+                agent.modelPattern = model.id;
+                saveAgent(agent);
+                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();
+        }
+    });
+}
+/**
+ * Ask for an optional session goal before starting.
+ */
+function askSessionGoal() {
+    return new Promise((resolve) => {
+        const screen = new SessionGoalScreen(tui);
+        screen.onSubmit = (goal) => resolve(goal.trim());
+        screen.onSkip = () => resolve("");
+        setScreen(screen);
+    });
+}
+/**
+ * Pick which agent to start (or auto-select if only one).
+ */
+function pickAgent() {
+    const agents = getAgents();
+    if (agents.length === 0) {
+        return showMessage("No agents", ["Create an agent first in Manage agents."], "error").then(() => null);
+    }
+    if (agents.length === 1) {
+        return Promise.resolve(agents[0]);
+    }
+    return new Promise((resolve) => {
+        const screen = new AgentPickerScreen(tui, agents);
+        screen.onSelect = (agent) => resolve(agent);
+        screen.onCancel = () => resolve(null);
+        setScreen(screen);
+    });
+}
+// ── Agent config sub-menu ─────────────────────────────────
+async function runAgentConfig(agentId) {
+    while (true) {
+        const agent = getAgent(agentId);
+        if (!agent)
+            return; // deleted
+        const action = await new Promise((resolve) => {
+            const screen = new AgentConfigScreen(tui, agent);
+            screen.onAction = resolve;
+            setScreen(screen);
+        });
+        switch (action) {
+            case "edit-name": {
+                const newName = await askName("Rename Agent", "Enter a new name for this agent.", agent.name);
+                if (newName) {
+                    agent.name = newName;
+                    saveAgent(agent);
+                }
+                break;
+            }
+            case "edit-instructions":
+                await editInstructions(agent);
+                break;
+            case "edit-discovery":
+                await editDiscovery(agent);
+                break;
+            case "edit-limits":
+                await editLimits(agent);
+                break;
+            case "edit-model":
+                await editModel(agent);
+                break;
+            case "delete": {
+                await showMessage("Deleted", [`Agent "${agent.name}" has been deleted.`], "info");
+                deleteAgent(agent.id);
+                return;
+            }
+            case "back":
+                return;
+        }
+    }
+}
+// ── Agent list ────────────────────────────────────────────
+async function runAgentList() {
+    while (true) {
+        const agents = getAgents();
+        const action = await new Promise((resolve) => {
+            const screen = new AgentListScreen(tui, agents);
+            screen.onAction = resolve;
+            setScreen(screen);
+        });
+        switch (action.type) {
+            case "create": {
+                const name = await askName("New Agent", "Give your agent a name.");
+                if (name) {
+                    const agent = createAgent(name);
+                    // Go straight into editing the new agent
+                    await runAgentConfig(agent.id);
+                }
+                break;
+            }
+            case "select":
+                await runAgentConfig(action.agent.id);
+                break;
+            case "back":
+                return;
+        }
+    }
+}
+// ── Running the agent ─────────────────────────────────────
+/**
+ * Fetch candidate profiles from the server's /api/discover endpoint.
+ */
+async function fetchCandidates(discovery) {
+    const config = getConfig();
+    const params = new URLSearchParams();
+    if (discovery.onlineOnly)
+        params.set("onlineOnly", "true");
+    params.set("notContactedInDays", String(discovery.recontactAfterDays));
+    if (discovery.includeKeywords.length > 0) {
+        params.set("keywords", discovery.includeKeywords.join(","));
+    }
+    if (discovery.excludeKeywords.length > 0) {
+        params.set("excludeKeywords", discovery.excludeKeywords.join(","));
+    }
+    if (discovery.excludeUsers.length > 0) {
+        params.set("excludeUsers", discovery.excludeUsers.join(","));
+    }
+    params.set("limit", String(discovery.maxScreenPerSession));
+    const res = await fetch(`${config.serverUrl}/api/discover?${params}`, {
+        headers: { Authorization: `Bearer ${config.token}` },
+    });
+    if (!res.ok)
+        throw new Error(`Discover API error: ${res.status}`);
+    const data = (await res.json());
+    return data.profiles;
+}
+/**
+ * Start the agent: pick agent → session goal → discover → screen → connect → run.
+ */
+async function runAgentSession() {
+    // 1. Pick agent
+    const agent = await pickAgent();
+    if (!agent)
+        return;
+    // 2. Init model for this agent
+    let activeModel;
+    try {
+        const { model } = await initInference(agent.modelPattern);
+        activeModel = model;
+    }
+    catch (err) {
+        await showMessage("Model error", [err instanceof Error ? err.message : "Failed to initialize model"], "error");
+        return;
+    }
+    // 3. Set agent instructions for inference
+    setAgentInstructions(agent.instructions);
+    // 4. Ask for session goal
+    const sessionGoal = await askSessionGoal();
+    const config = getConfig();
+    const discovery = agent.discovery;
+    const limits = agent.limits;
+    // 5. Show the running screen
+    const screen = new AgentRunningScreen(tui, activeModel, config.serverUrl, agent.name, sessionGoal);
+    const done = new Promise((resolve) => {
+        screen.onStop = () => {
+            stopAgent();
+            resolve();
+        };
+    });
+    setScreen(screen);
+    const log = (line) => screen.addLog(line);
+    // 6. Start the WebSocket agent (for incoming requests) with per-agent limits
+    startAgent(limits, agent.id, agent.name, log);
+    // 7. Discovery + screening (outbound)
+    screen.setStatus("discovering candidates...");
+    try {
+        const candidates = await fetchCandidates(discovery);
+        if (candidates.length === 0) {
+            log(colors.gray("No candidates match your discovery filters."));
+            log(colors.gray("Waiting for incoming conversations..."));
+            screen.setStatus("waiting for conversations...");
+        }
+        else {
+            log(colors.cyan(`📡 Found ${candidates.length} candidates, screening...`));
+            screen.setStatus(`screening ${candidates.length} profiles...`);
+            const results = await screenProfiles(candidates, agent.instructions, sessionGoal, discovery.matchThreshold, discovery.maxScreenPerSession, (screened, total, result) => {
+                const icon = result.score >= discovery.matchThreshold
+                    ? colors.green("✓")
+                    : colors.gray("⊘");
+                const name = `@${result.profile.githubUsername}`;
+                const scoreStr = result.score >= discovery.matchThreshold
+                    ? colors.green(`${result.score}/10`)
+                    : colors.gray(`${result.score}/10`);
+                log(`  ${icon} ${name} ${scoreStr} — ${colors.gray(result.reason)}`);
+                screen.setStatus(`screening ${screened}/${total}...`);
+            });
+            const matches = results.filter((r) => r.score >= discovery.matchThreshold);
+            log("");
+            if (matches.length === 0) {
+                log(colors.yellow("No strong matches found. Waiting for incoming conversations..."));
+            }
+            else {
+                log(colors.green(`Found ${matches.length} match${matches.length === 1 ? "" : "es"}. Starting conversations...`));
+                log("");
+                // Initiate conversations with matches
+                for (const match of matches) {
+                    if (!match.profile.online) {
+                        log(colors.gray(`  ⊘ @${match.profile.githubUsername} is offline, skipping`));
+                        continue;
+                    }
+                    log(colors.cyan(`  🤝 Reaching out to @${match.profile.githubUsername} (${match.score}/10: ${match.reason})`));
+                    // Send start_conversation via WebSocket
+                    sendToServer({
+                        type: "start_conversation",
+                        withUserId: match.profile.id,
+                    });
+                    // Respect cooldown between outreach
+                    if (limits.cooldownSeconds > 0) {
+                        await new Promise((r) => setTimeout(r, limits.cooldownSeconds * 1000));
+                    }
+                }
+            }
+            screen.setStatus(`${matches.length} matches • waiting for conversations...`);
+        }
+    }
+    catch (err) {
+        log(colors.red(`Discovery failed: ${err instanceof Error ? err.message : err}`));
+        screen.setStatus("waiting for conversations...");
+    }
+    return done;
+}
+// ── Dashboard loop ────────────────────────────────────────
+async function runDashboard() {
+    while (true) {
+        const config = getConfig();
+        const agents = getAgents();
+        const action = await new Promise((resolve) => {
+            const dashboard = new DashboardScreen(tui, {
+                loggedIn: !!config.token,
+                model: detectedModel,
+                agentCount: agents.length,
+                serverUrl: config.serverUrl,
+            });
+            dashboard.onAction = resolve;
+            setScreen(dashboard);
+        });
+        switch (action) {
+            case "start": {
+                const conf = getConfig();
+                if (!conf.token) {
+                    await showMessage("Not logged in", ["Run login first."], "error");
+                    break;
+                }
+                await runAgentSession();
+                break;
+            }
+            case "agents":
+                await runAgentList();
+                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,49 @@
+export type AgentLimits = {
+    maxConcurrentConversations: number;
+    maxMessagesPerConversation: number;
+    maxResponseLength: number;
+    cooldownSeconds: number;
+    maxConversationsPerSession: number;
+    autoStopIdleMinutes: number;
+};
+export declare const DEFAULT_LIMITS: AgentLimits;
+export type DiscoverySettings = {
+    recontactAfterDays: number;
+    onlineOnly: boolean;
+    includeKeywords: string[];
+    excludeKeywords: string[];
+    excludeUsers: string[];
+    priorityUsers: string[];
+    matchThreshold: number;
+    maxScreenPerSession: number;
+};
+export declare const DEFAULT_DISCOVERY: DiscoverySettings;
+/**
+ * A single agent profile with all its settings.
+ */
+export type AgentProfile = {
+    id: string;
+    name: string;
+    instructions: string;
+    discovery: DiscoverySettings;
+    limits: AgentLimits;
+    modelPattern?: string;
+};
+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;
+/**
+ * Migrate legacy single-agent setup to new multi-agent format.
+ * Runs once: if ~/.swarmlancer/agent.md exists and no agents dir.
+ */
+export declare function migrateLegacyAgent(): void;
+export declare function getAgents(): AgentProfile[];
+export declare function getAgent(id: string): AgentProfile | undefined;
+export declare function saveAgent(agent: AgentProfile): void;
+export declare function deleteAgent(id: string): void;
+export declare function createAgent(name: string): AgentProfile;