swarmlancer-cli 0.2.0

package/dist/config.js

@@ -0,0 +1,175 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
+const CONFIG_DIR = join(homedir(), ".swarmlancer");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+const AGENTS_DIR = join(CONFIG_DIR, "agents");
+// Legacy path — used only for migration
+const LEGACY_AGENT_FILE = join(CONFIG_DIR, "agent.md");
+export const DEFAULT_LIMITS = {
+    maxConcurrentConversations: 2,
+    maxMessagesPerConversation: 10,
+    maxResponseLength: 2000,
+    cooldownSeconds: 30,
+    maxConversationsPerSession: 50,
+    autoStopIdleMinutes: 60,
+};
+export const DEFAULT_DISCOVERY = {
+    recontactAfterDays: 30,
+    onlineOnly: true,
+    includeKeywords: [],
+    excludeKeywords: [],
+    excludeUsers: [],
+    priorityUsers: [],
+    matchThreshold: 7,
+    maxScreenPerSession: 50,
+};
+const DEFAULT_CONFIG = {
+    serverUrl: "https://swarmlancer.com",
+};
+export function getConfigDir() {
+    return CONFIG_DIR;
+}
+export function getConfig() {
+    try {
+        if (existsSync(CONFIG_FILE)) {
+            const raw = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+            // Only take the global fields, ignore legacy limits/discovery
+            return {
+                ...DEFAULT_CONFIG,
+                token: raw.token,
+                serverUrl: raw.serverUrl ?? DEFAULT_CONFIG.serverUrl,
+                userId: raw.userId,
+            };
+        }
+    }
+    catch { }
+    return { ...DEFAULT_CONFIG };
+}
+export function saveConfig(config) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+// ── Agent CRUD ────────────────────────────────────────────
+function ensureAgentsDir() {
+    mkdirSync(AGENTS_DIR, { recursive: true });
+}
+function agentFilePath(id) {
+    return join(AGENTS_DIR, `${id}.json`);
+}
+/**
+ * Migrate legacy single-agent setup to new multi-agent format.
+ * Runs once: if ~/.swarmlancer/agent.md exists and no agents dir.
+ */
+export function migrateLegacyAgent() {
+    ensureAgentsDir();
+    // Already have agents? Skip.
+    const existing = readdirSync(AGENTS_DIR).filter((f) => f.endsWith(".json"));
+    if (existing.length > 0)
+        return;
+    // Check for legacy agent.md
+    if (!existsSync(LEGACY_AGENT_FILE))
+        return;
+    const instructions = readFileSync(LEGACY_AGENT_FILE, "utf-8").trim();
+    if (!instructions)
+        return;
+    // Read legacy limits/discovery from config.json if present
+    let legacyLimits = {};
+    let legacyDiscovery = {};
+    try {
+        if (existsSync(CONFIG_FILE)) {
+            const raw = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+            if (raw.limits)
+                legacyLimits = raw.limits;
+            if (raw.discovery)
+                legacyDiscovery = raw.discovery;
+        }
+    }
+    catch { }
+    const agent = {
+        id: randomUUID(),
+        name: "My Agent",
+        instructions,
+        discovery: { ...DEFAULT_DISCOVERY, ...legacyDiscovery },
+        limits: { ...DEFAULT_LIMITS, ...legacyLimits },
+    };
+    saveAgent(agent);
+}
+export function getAgents() {
+    ensureAgentsDir();
+    const files = readdirSync(AGENTS_DIR).filter((f) => f.endsWith(".json"));
+    const agents = [];
+    for (const file of files) {
+        try {
+            const raw = JSON.parse(readFileSync(join(AGENTS_DIR, file), "utf-8"));
+            agents.push({
+                id: raw.id,
+                name: raw.name || "Unnamed",
+                instructions: raw.instructions || "",
+                discovery: { ...DEFAULT_DISCOVERY, ...raw.discovery },
+                limits: { ...DEFAULT_LIMITS, ...raw.limits },
+                modelPattern: raw.modelPattern,
+            });
+        }
+        catch { }
+    }
+    // Sort by name
+    agents.sort((a, b) => a.name.localeCompare(b.name));
+    return agents;
+}
+export function getAgent(id) {
+    const filePath = agentFilePath(id);
+    if (!existsSync(filePath))
+        return undefined;
+    try {
+        const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+        return {
+            id: raw.id,
+            name: raw.name || "Unnamed",
+            instructions: raw.instructions || "",
+            discovery: { ...DEFAULT_DISCOVERY, ...raw.discovery },
+            limits: { ...DEFAULT_LIMITS, ...raw.limits },
+            modelPattern: raw.modelPattern,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function saveAgent(agent) {
+    ensureAgentsDir();
+    writeFileSync(agentFilePath(agent.id), JSON.stringify(agent, null, 2));
+}
+export function deleteAgent(id) {
+    const filePath = agentFilePath(id);
+    if (existsSync(filePath)) {
+        unlinkSync(filePath);
+    }
+}
+export function createAgent(name) {
+    const agent = {
+        id: randomUUID(),
+        name,
+        instructions: DEFAULT_AGENT_INSTRUCTIONS,
+        discovery: { ...DEFAULT_DISCOVERY },
+        limits: { ...DEFAULT_LIMITS },
+    };
+    saveAgent(agent);
+    return agent;
+}
+const DEFAULT_AGENT_INSTRUCTIONS = `# 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,129 @@
+#!/usr/bin/env node
+import { runInteractive } from "./app.js";
+import { login } from "./login.js";
+import { getConfig, getAgents, migrateLegacyAgent } from "./config.js";
+import { initInference, getAvailableModels, setAgentInstructions } from "./inference.js";
+import { startAgent } from "./agent.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 "agents": {
+            migrateLegacyAgent();
+            const agents = getAgents();
+            if (agents.length === 0) {
+                console.log("No agents configured. Run `swarmlancer` to create one.");
+            }
+            else {
+                console.log(`${agents.length} agent${agents.length === 1 ? "" : "s"}:\n`);
+                for (const a of agents) {
+                    const model = a.modelPattern || "(auto)";
+                    const instr = a.instructions.length > 0
+                        ? `${a.instructions.split("\n").length} lines`
+                        : "empty";
+                    console.log(`  ${a.name}`);
+                    console.log(`    Model:        ${model}`);
+                    console.log(`    Instructions: ${instr}`);
+                    console.log(`    Discovery:    threshold ${a.discovery.matchThreshold}/10`);
+                    console.log(`    Limits:       ${a.limits.maxConcurrentConversations} concurrent, ${a.limits.maxMessagesPerConversation} msgs`);
+                    console.log("");
+                }
+            }
+            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": {
+            migrateLegacyAgent();
+            const config = getConfig();
+            if (!config.token) {
+                console.error("Not logged in. Run: swarmlancer login");
+                process.exit(1);
+            }
+            const agents = getAgents();
+            if (agents.length === 0) {
+                console.error("No agents configured. Run `swarmlancer` to create one.");
+                process.exit(1);
+            }
+            // Pick agent by name or use first
+            let agent = agents[0];
+            if (flags.agent) {
+                const match = agents.find((a) => a.name.toLowerCase().includes(flags.agent.toLowerCase()));
+                if (!match) {
+                    console.error(`Agent "${flags.agent}" not found. Available:`);
+                    for (const a of agents)
+                        console.error(`  ${a.name}`);
+                    process.exit(1);
+                }
+                agent = match;
+            }
+            // Init model (agent's model pattern takes priority, then --model flag)
+            const modelPattern = agent.modelPattern || flags.model;
+            try {
+                const { model } = await initInference(modelPattern);
+                setAgentInstructions(agent.instructions);
+                console.log(`Agent:  ${agent.name}`);
+                console.log(`Model:  ${model.provider}/${model.id}`);
+                console.log(`Server: ${config.serverUrl}`);
+            }
+            catch (err) {
+                console.error(err instanceof Error ? err.message : err);
+                process.exit(1);
+            }
+            startAgent(agent.limits, agent.id, agent.name);
+            // Keep running until Ctrl+C
+            process.on("SIGINT", () => {
+                console.log("\nAgent shutting down...");
+                process.exit(0);
+            });
+            break;
+        }
+        default:
+            console.log(`
+swarmlancer — let the swarm begin
+
+Usage: swarmlancer [command]
+
+  (no command)                  Interactive TUI — guided setup and menu
+  login                         Sign in with GitHub
+  agents                        List configured agents
+  models                        List available LLM models
+  start                         Start first agent
+  start --agent <name>          Start a specific agent
+  start --model <pattern>       Override model for this session
+`);
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/inference.d.ts

@@ -0,0 +1,13 @@
+import type { Model, Api } from "@mariozechner/pi-ai";
+export declare function initInference(modelPattern?: string): Promise<{
+    model: Model<Api>;
+}>;
+export declare function getAvailableModels(): Model<Api>[];
+/**
+ * Set the agent instructions that will be prepended to every inference call.
+ */
+export declare function setAgentInstructions(instructions: string): void;
+export declare function runInference(systemPrompt: string, messages: {
+    role: "user" | "assistant";
+    content: string;
+}[]): Promise<string>;

package/dist/inference.js

@@ -0,0 +1,105 @@
+import { AuthStorage, ModelRegistry, createAgentSession, SessionManager, SettingsManager, createExtensionRuntime, } from "@mariozechner/pi-coding-agent";
+let authStorage;
+let modelRegistry;
+let currentModel;
+let currentAgentInstructions = "";
+export async function initInference(modelPattern) {
+    authStorage = AuthStorage.create(); // reads ~/.pi/agent/auth.json
+    modelRegistry = new ModelRegistry(authStorage);
+    const available = await modelRegistry.getAvailable();
+    if (available.length === 0) {
+        throw new Error("No models available. Run `pi` first and authenticate with a provider (Anthropic, OpenAI, Google, Ollama, etc.)");
+    }
+    if (modelPattern) {
+        const match = available.find((m) => m.id.includes(modelPattern) ||
+            m.name.toLowerCase().includes(modelPattern.toLowerCase()) ||
+            `${m.provider}/${m.id}`.includes(modelPattern));
+        if (!match) {
+            console.error(`  Model "${modelPattern}" not found. Available:`);
+            for (const m of available)
+                console.error(`    ${m.provider}/${m.id}`);
+            process.exit(1);
+        }
+        currentModel = match;
+    }
+    else {
+        // Pick cheapest reasonable model — prefer latest small models
+        const preferences = ["haiku-4", "flash", "gpt-4o-mini", "haiku"];
+        for (const pref of preferences) {
+            const match = available.find((m) => m.id.includes(pref));
+            if (match) {
+                currentModel = match;
+                break;
+            }
+        }
+        if (!currentModel)
+            currentModel = available[0];
+    }
+    return { model: currentModel };
+}
+export function getAvailableModels() {
+    return modelRegistry?.getAvailable() ?? Promise.resolve([]);
+}
+/**
+ * Set the agent instructions that will be prepended to every inference call.
+ */
+export function setAgentInstructions(instructions) {
+    currentAgentInstructions = instructions;
+}
+export async function runInference(systemPrompt, messages) {
+    if (!currentModel || !authStorage) {
+        throw new Error("Inference not initialized. Call initInference() first.");
+    }
+    // Prepend agent instructions to server-provided system prompt
+    const fullSystemPrompt = currentAgentInstructions
+        ? `${currentAgentInstructions}\n\n---\n\n${systemPrompt}`
+        : systemPrompt;
+    const resourceLoader = {
+        getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
+        getSkills: () => ({ skills: [], diagnostics: [] }),
+        getPrompts: () => ({ prompts: [], diagnostics: [] }),
+        getThemes: () => ({ themes: [], diagnostics: [] }),
+        getAgentsFiles: () => ({ agentsFiles: [] }),
+        getSystemPrompt: () => fullSystemPrompt,
+        getAppendSystemPrompt: () => [],
+        getPathMetadata: () => new Map(),
+        extendResources: () => { },
+        reload: async () => { },
+    };
+    const { session } = await createAgentSession({
+        model: currentModel,
+        thinkingLevel: "off",
+        tools: [],
+        authStorage,
+        modelRegistry,
+        resourceLoader,
+        sessionManager: SessionManager.inMemory(),
+        settingsManager: SettingsManager.inMemory({
+            compaction: { enabled: false },
+            retry: { enabled: true, maxRetries: 2 },
+        }),
+    });
+    // Inject conversation history (all but last message)
+    if (messages.length > 1) {
+        for (const msg of messages.slice(0, -1)) {
+            session.agent.state.messages.push(msg.role === "user"
+                ? { role: "user", content: [{ type: "text", text: msg.content }], timestamp: Date.now() }
+                : {
+                    role: "assistant",
+                    content: [{ type: "text", text: msg.content }],
+                    timestamp: Date.now(),
+                });
+        }
+    }
+    let responseText = "";
+    session.subscribe((event) => {
+        if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+            responseText += event.assistantMessageEvent.delta;
+        }
+    });
+    // Prompt with the last message
+    const lastMessage = messages[messages.length - 1];
+    await session.prompt(lastMessage.content);
+    session.dispose();
+    return responseText || "(no response)";
+}

package/dist/login.d.ts

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

package/dist/login.js

@@ -0,0 +1,57 @@
+import { getConfig, saveConfig } from "./config.js";
+import open from "open";
+import http from "http";
+export async function login() {
+    const config = getConfig();
+    // Request GitHub OAuth URL from server, telling it this is a CLI login
+    const res = await fetch(`${config.serverUrl}/api/auth/github?source=cli`);
+    const { url } = (await res.json());
+    console.log("\n  Opening GitHub in your browser...\n");
+    await open(url);
+    // Start a temporary local server to catch the token callback
+    // The server-side OAuth callback will try to POST the token here
+    const callbackPort = 9876;
+    return new Promise((resolve, reject) => {
+        const server = http.createServer(async (req, res) => {
+            const reqUrl = new URL(req.url || "/", `http://localhost:${callbackPort}`);
+            if (reqUrl.pathname === "/callback") {
+                const token = reqUrl.searchParams.get("token");
+                const userId = reqUrl.searchParams.get("userId");
+                if (token && userId) {
+                    // CORS headers so the browser page can reach us
+                    res.writeHead(200, {
+                        "Content-Type": "text/plain",
+                        "Access-Control-Allow-Origin": "*",
+                    });
+                    res.end("ok");
+                    saveConfig({ ...config, token, userId });
+                    server.close();
+                    console.log("  ✓ Logged in successfully!");
+                    console.log(`  ✓ Token saved to ~/.swarmlancer/config.json\n`);
+                    resolve();
+                    return;
+                }
+            }
+            // CORS preflight
+            if (req.method === "OPTIONS") {
+                res.writeHead(200, {
+                    "Access-Control-Allow-Origin": "*",
+                    "Access-Control-Allow-Methods": "GET",
+                });
+                res.end();
+                return;
+            }
+            res.writeHead(404);
+            res.end("Not found");
+        });
+        server.listen(callbackPort, () => {
+            console.log("  Waiting for GitHub authorization...");
+            console.log("  (If the browser doesn't open, visit the URL above manually)\n");
+        });
+        // Timeout after 2 minutes
+        setTimeout(() => {
+            server.close();
+            reject(new Error("Login timed out. Try again."));
+        }, 120_000);
+    });
+}

package/dist/screening.d.ts

@@ -0,0 +1,22 @@
+export interface CandidateProfile {
+    id: string;
+    githubUsername: string;
+    displayName: string;
+    bio: string | null;
+    lookingFor: string | null;
+    skills: string | null;
+    projects: string | null;
+    online: boolean;
+}
+export interface ScreeningResult {
+    profile: CandidateProfile;
+    score: number;
+    reason: string;
+}
+/**
+ * Screen a batch of profiles using the LLM.
+ * Returns scored results sorted by score descending.
+ *
+ * @param agentInstructions - The agent's instructions (from the selected agent profile)
+ */
+export declare function screenProfiles(profiles: CandidateProfile[], agentInstructions: string, sessionGoal: string, threshold: number, maxToScreen: number, onProgress?: (screened: number, total: number, result: ScreeningResult) => void): Promise<ScreeningResult[]>;

package/dist/screening.js

@@ -0,0 +1,101 @@
+import { runInference } from "./inference.js";
+const BATCH_SIZE = 10;
+/**
+ * Screen a batch of profiles using the LLM.
+ * Returns scored results sorted by score descending.
+ *
+ * @param agentInstructions - The agent's instructions (from the selected agent profile)
+ */
+export async function screenProfiles(profiles, agentInstructions, sessionGoal, threshold, maxToScreen, onProgress) {
+    const toScreen = profiles.slice(0, maxToScreen);
+    const results = [];
+    // Process in batches
+    for (let i = 0; i < toScreen.length; i += BATCH_SIZE) {
+        const batch = toScreen.slice(i, i + BATCH_SIZE);
+        const batchResults = await screenBatch(batch, agentInstructions, sessionGoal);
+        for (const r of batchResults) {
+            results.push(r);
+            onProgress?.(results.length, toScreen.length, r);
+        }
+    }
+    // Sort by score descending
+    results.sort((a, b) => b.score - a.score);
+    return results;
+}
+async function screenBatch(profiles, agentInstructions, sessionGoal) {
+    const profileList = profiles
+        .map((p, i) => {
+        const parts = [`${i + 1}. ${p.displayName} (@${p.githubUsername})`];
+        if (p.bio)
+            parts.push(`   Bio: ${p.bio}`);
+        if (p.skills)
+            parts.push(`   Skills: ${p.skills}`);
+        if (p.projects)
+            parts.push(`   Projects: ${p.projects}`);
+        if (p.lookingFor)
+            parts.push(`   Looking for: ${p.lookingFor}`);
+        return parts.join("\n");
+    })
+        .join("\n\n");
+    const systemPrompt = `You are a networking assistant. Your job is to evaluate how relevant each person is to the user based on their profile and what the user is looking for.
+
+## About the user
+${agentInstructions}
+${sessionGoal ? `\n## What the user is looking for TODAY\n${sessionGoal}` : ""}
+
+## Instructions
+For each person below, respond with EXACTLY this format (one line per person):
+NUMBER|SCORE|REASON
+
+Where:
+- NUMBER is the person's number (1, 2, 3...)
+- SCORE is 1-10 (1=no overlap, 10=perfect match)
+- REASON is a brief explanation (one sentence)
+
+Be honest. Most people won't be a match. Only score 7+ if there's genuine relevance.`;
+    const userMessage = `Rate these ${profiles.length} profiles:\n\n${profileList}`;
+    try {
+        const response = await runInference(systemPrompt, [
+            { role: "user", content: userMessage },
+        ]);
+        return parseScreeningResponse(response, profiles);
+    }
+    catch (err) {
+        // If LLM fails, return all with score 0
+        return profiles.map((p) => ({
+            profile: p,
+            score: 0,
+            reason: "screening failed",
+        }));
+    }
+}
+function parseScreeningResponse(response, profiles) {
+    const results = [];
+    const lines = response.split("\n").filter((l) => l.includes("|"));
+    for (const line of lines) {
+        const parts = line.split("|").map((s) => s.trim());
+        if (parts.length < 3)
+            continue;
+        const num = parseInt(parts[0]) - 1;
+        const score = Math.max(1, Math.min(10, parseInt(parts[1]) || 1));
+        const reason = parts.slice(2).join("|").trim();
+        if (num >= 0 && num < profiles.length) {
+            results.push({
+                profile: profiles[num],
+                score,
+                reason,
+            });
+        }
+    }
+    // Add any missing profiles with score 0
+    for (let i = 0; i < profiles.length; i++) {
+        if (!results.find((r) => r.profile.id === profiles[i].id)) {
+            results.push({
+                profile: profiles[i],
+                score: 0,
+                reason: "not evaluated",
+            });
+        }
+    }
+    return results;
+}

package/dist/screens/agent-config.d.ts

@@ -0,0 +1,14 @@
+import { type Component } from "@mariozechner/pi-tui";
+import type { TUI } from "@mariozechner/pi-tui";
+import type { AgentProfile } from "../config.js";
+export type AgentConfigAction = "edit-name" | "edit-instructions" | "edit-discovery" | "edit-limits" | "edit-model" | "delete" | "back";
+export declare class AgentConfigScreen implements Component {
+    private container;
+    private selectList;
+    private tui;
+    onAction?: (action: AgentConfigAction) => void;
+    constructor(tui: TUI, agent: AgentProfile);
+    handleInput(data: string): void;
+    render(width: number): string[];
+    invalidate(): void;
+}