@simonfestl/husky-cli 1.15.0 → 1.16.0

package/dist/commands/interactive/auth.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Interactive Mode: Auth Module
+ *
+ * Provides menu-based authentication and API key management.
+ */
+export declare function authMenu(): Promise<void>;

package/dist/commands/interactive/auth.js

@@ -0,0 +1,227 @@
+/**
+ * Interactive Mode: Auth Module
+ *
+ * Provides menu-based authentication and API key management.
+ */
+import { select, input, confirm } from "@inquirer/prompts";
+import { getConfig, setConfig, setSessionConfig, clearSessionConfig } from "../config.js";
+import { pressEnterToContinue } from "./utils.js";
+export async function authMenu() {
+    console.log("\n  AUTH");
+    console.log("  " + "-".repeat(50));
+    console.log("  API keys and session management");
+    console.log("");
+    const menuItems = [
+        { name: "🔑 Login (Create Session)", value: "login" },
+        { name: "📊 Session Status", value: "session" },
+        { name: "🔄 Refresh Token", value: "refresh" },
+        { name: "🚪 Logout", value: "logout" },
+        { name: "🔐 Show API Key", value: "show-key" },
+        { name: "✏️  Set API Key", value: "set-key" },
+        { name: "← Back", value: "back" },
+    ];
+    const choice = await select({
+        message: "Auth Action:",
+        choices: menuItems,
+    });
+    switch (choice) {
+        case "login":
+            await login();
+            break;
+        case "session":
+            await sessionStatus();
+            break;
+        case "refresh":
+            await refreshToken();
+            break;
+        case "logout":
+            await logout();
+            break;
+        case "show-key":
+            await showApiKey();
+            break;
+        case "set-key":
+            await setApiKey();
+            break;
+        case "back":
+            return;
+    }
+}
+async function login() {
+    try {
+        const config = getConfig();
+        if (!config.apiUrl) {
+            console.error("\n  Error: API URL not configured. Run 'husky config set api-url <url>' first.\n");
+            await pressEnterToContinue();
+            return;
+        }
+        const agentName = await input({
+            message: "Agent name:",
+            default: "interactive-cli",
+            validate: (v) => (v.length > 0 ? true : "Agent name is required"),
+        });
+        console.log("\n  Creating session...");
+        const res = await fetch(`${config.apiUrl}/api/auth/session`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({ agent: agentName }),
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            console.error(`\n  Error: ${error}\n`);
+        }
+        else {
+            const data = await res.json();
+            // Save session token
+            setSessionConfig({
+                token: data.token,
+                expiresAt: data.expiresAt,
+                agent: agentName,
+                role: data.role || "",
+            });
+            console.log("\n  Session created!");
+            console.log(`  Agent: ${agentName}`);
+            console.log(`  Expires: ${new Date(data.expiresAt).toLocaleString()}`);
+            console.log("");
+        }
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error creating session:", error);
+        await pressEnterToContinue();
+    }
+}
+async function sessionStatus() {
+    try {
+        const config = getConfig();
+        console.log("\n  SESSION STATUS");
+        console.log("  " + "-".repeat(50));
+        if (!config.sessionToken) {
+            console.log("  No active session.");
+            console.log("  Use 'Login' to create a new session.");
+        }
+        else {
+            const expiresAt = config.sessionExpiresAt ? new Date(config.sessionExpiresAt) : null;
+            const isExpired = expiresAt ? expiresAt < new Date() : true;
+            console.log(`  Agent: ${config.sessionAgent || "unknown"}`);
+            console.log(`  Token: ${config.sessionToken.substring(0, 20)}...`);
+            console.log(`  Expires: ${expiresAt ? expiresAt.toLocaleString() : "unknown"}`);
+            console.log(`  Status: ${isExpired ? "❌ EXPIRED" : "✅ VALID"}`);
+        }
+        console.log("");
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error checking session:", error);
+        await pressEnterToContinue();
+    }
+}
+async function refreshToken() {
+    try {
+        const config = getConfig();
+        if (!config.apiUrl) {
+            console.error("\n  Error: API URL not configured.\n");
+            await pressEnterToContinue();
+            return;
+        }
+        if (!config.sessionToken) {
+            console.error("\n  Error: No active session to refresh.\n");
+            await pressEnterToContinue();
+            return;
+        }
+        console.log("\n  Refreshing token...");
+        const res = await fetch(`${config.apiUrl}/api/auth/refresh`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${config.sessionToken}`,
+            },
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            console.error(`\n  Error: ${error}\n`);
+        }
+        else {
+            const data = await res.json();
+            const currentConfig = getConfig();
+            setSessionConfig({
+                token: data.token,
+                expiresAt: data.expiresAt,
+                agent: currentConfig.sessionAgent || "",
+                role: data.role || currentConfig.sessionRole || "",
+            });
+            console.log("\n  Token refreshed!");
+            console.log(`  New expiry: ${new Date(data.expiresAt).toLocaleString()}`);
+            console.log("");
+        }
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error refreshing token:", error);
+        await pressEnterToContinue();
+    }
+}
+async function logout() {
+    try {
+        const config = getConfig();
+        if (!config.sessionToken) {
+            console.log("\n  No active session.\n");
+            await pressEnterToContinue();
+            return;
+        }
+        const confirmed = await confirm({
+            message: "Are you sure you want to logout?",
+            default: true,
+        });
+        if (!confirmed) {
+            console.log("\n  Cancelled.\n");
+            await pressEnterToContinue();
+            return;
+        }
+        // Clear session from config
+        clearSessionConfig();
+        console.log("\n  Logged out successfully!\n");
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error logging out:", error);
+        await pressEnterToContinue();
+    }
+}
+async function showApiKey() {
+    const config = getConfig();
+    console.log("\n  API KEY");
+    console.log("  " + "-".repeat(50));
+    if (!config.apiKey) {
+        console.log("  No API key configured.");
+    }
+    else {
+        const masked = config.apiKey.substring(0, 8) + "..." + config.apiKey.substring(config.apiKey.length - 4);
+        console.log(`  API Key: ${masked}`);
+        console.log(`  Length: ${config.apiKey.length} characters`);
+    }
+    console.log("");
+    await pressEnterToContinue();
+}
+async function setApiKey() {
+    try {
+        const key = await input({
+            message: "New API Key:",
+            validate: (v) => {
+                if (v.length < 16)
+                    return "API key must be at least 16 characters";
+                return true;
+            },
+        });
+        setConfig("apiKey", key);
+        console.log("\n  API Key saved!\n");
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error setting API key:", error);
+        await pressEnterToContinue();
+    }
+}

package/dist/commands/interactive/brain.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Interactive Mode: Brain Module
+ *
+ * Provides menu-based agent memory and learning management.
+ */
+export declare function brainMenu(): Promise<void>;

package/dist/commands/interactive/brain.js

@@ -0,0 +1,356 @@
+/**
+ * Interactive Mode: Brain Module
+ *
+ * Provides menu-based agent memory and learning management.
+ */
+import { select, input, confirm } from "@inquirer/prompts";
+import { ensureConfig, pressEnterToContinue, truncate } from "./utils.js";
+export async function brainMenu() {
+    const config = ensureConfig();
+    console.log("\n  BRAIN");
+    console.log("  " + "-".repeat(50));
+    console.log("  Agent memory and learning management");
+    console.log("");
+    const menuItems = [
+        { name: "📋 List Memories", value: "list" },
+        { name: "🔍 Recall (Search)", value: "recall" },
+        { name: "💡 Remember (Add)", value: "remember" },
+        { name: "📤 Publish Memory", value: "publish" },
+        { name: "👥 Shared Memories", value: "shared" },
+        { name: "👍 Boost Memory", value: "boost" },
+        { name: "📦 Archive", value: "archive" },
+        { name: "🗑️  Delete", value: "delete" },
+        { name: "🧹 Cleanup Old", value: "cleanup" },
+        { name: "← Back", value: "back" },
+    ];
+    const choice = await select({
+        message: "Brain Action:",
+        choices: menuItems,
+    });
+    switch (choice) {
+        case "list":
+            await listMemories(config);
+            break;
+        case "recall":
+            await recallMemory(config);
+            break;
+        case "remember":
+            await rememberContent(config);
+            break;
+        case "publish":
+            await publishMemory(config);
+            break;
+        case "shared":
+            await sharedMemories(config);
+            break;
+        case "boost":
+            await boostMemory(config);
+            break;
+        case "archive":
+            await archiveMemory(config);
+            break;
+        case "delete":
+            await deleteMemory(config);
+            break;
+        case "cleanup":
+            await cleanupMemories(config);
+            break;
+        case "back":
+            return;
+    }
+}
+async function listMemories(config) {
+    try {
+        const limit = await input({
+            message: "Number of memories to show (default 20):",
+            default: "20",
+        });
+        const res = await fetch(`${config.apiUrl}/api/brain/memories?limit=${limit}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            console.error(`\n  Error: API returned ${res.status}\n`);
+            await pressEnterToContinue();
+            return;
+        }
+        const memories = await res.json();
+        console.log("\n  MEMORIES");
+        console.log("  " + "-".repeat(70));
+        if (memories.length === 0) {
+            console.log("  No memories found.");
+        }
+        else {
+            console.log(`  ${"ID".padEnd(12)} ${"SCORE".padEnd(8)} ${"TAGS".padEnd(20)} ${"CONTENT"}`);
+            console.log("  " + "-".repeat(70));
+            for (const mem of memories) {
+                const score = mem.qualityScore !== undefined ? String(mem.qualityScore) : "-";
+                const tags = mem.tags.slice(0, 2).join(", ");
+                console.log(`  ${mem.id.substring(0, 10).padEnd(12)} ${score.padEnd(8)} ${truncate(tags, 18).padEnd(20)} ${truncate(mem.content, 30)}`);
+            }
+        }
+        console.log("");
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error fetching memories:", error);
+        await pressEnterToContinue();
+    }
+}
+async function recallMemory(config) {
+    try {
+        const query = await input({
+            message: "Search query:",
+            validate: (v) => (v.length > 0 ? true : "Query is required"),
+        });
+        const res = await fetch(`${config.apiUrl}/api/brain/recall?query=${encodeURIComponent(query)}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            console.error(`\n  Error: API returned ${res.status}\n`);
+            await pressEnterToContinue();
+            return;
+        }
+        const memories = await res.json();
+        console.log("\n  SEARCH RESULTS");
+        console.log("  " + "-".repeat(70));
+        if (memories.length === 0) {
+            console.log("  No matching memories found.");
+        }
+        else {
+            for (const mem of memories) {
+                console.log(`  ID: ${mem.id}`);
+                console.log(`  Tags: ${mem.tags.join(", ")}`);
+                console.log(`  Content: ${mem.content.substring(0, 100)}...`);
+                console.log("  " + "-".repeat(40));
+            }
+        }
+        console.log("");
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error searching memories:", error);
+        await pressEnterToContinue();
+    }
+}
+async function rememberContent(config) {
+    try {
+        const content = await input({
+            message: "Content to remember:",
+            validate: (v) => (v.length > 0 ? true : "Content is required"),
+        });
+        const tagsInput = await input({
+            message: "Tags (comma-separated):",
+            default: "",
+        });
+        const tags = tagsInput.split(",").map(t => t.trim()).filter(t => t.length > 0);
+        const res = await fetch(`${config.apiUrl}/api/brain/remember`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({ content, tags }),
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            console.error(`\n  Error: ${error}\n`);
+        }
+        else {
+            const data = await res.json();
+            console.log(`\n  Memory saved! ID: ${data.id || "created"}\n`);
+        }
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error saving memory:", error);
+        await pressEnterToContinue();
+    }
+}
+async function publishMemory(config) {
+    try {
+        const id = await input({
+            message: "Memory ID to publish:",
+            validate: (v) => (v.length > 0 ? true : "ID is required"),
+        });
+        const visibility = await select({
+            message: "Visibility:",
+            choices: [
+                { name: "Team", value: "team" },
+                { name: "Public", value: "public" },
+            ],
+        });
+        const res = await fetch(`${config.apiUrl}/api/brain/publish/${id}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({ visibility }),
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            console.error(`\n  Error: ${error}\n`);
+        }
+        else {
+            console.log(`\n  Memory published with visibility: ${visibility}\n`);
+        }
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error publishing memory:", error);
+        await pressEnterToContinue();
+    }
+}
+async function sharedMemories(config) {
+    try {
+        const res = await fetch(`${config.apiUrl}/api/brain/shared`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            console.error(`\n  Error: API returned ${res.status}\n`);
+            await pressEnterToContinue();
+            return;
+        }
+        const memories = await res.json();
+        console.log("\n  SHARED MEMORIES");
+        console.log("  " + "-".repeat(70));
+        if (memories.length === 0) {
+            console.log("  No shared memories found.");
+        }
+        else {
+            for (const mem of memories) {
+                console.log(`  ID: ${mem.id}`);
+                console.log(`  From: ${mem.agentId}`);
+                console.log(`  Score: ${mem.qualityScore || "-"}`);
+                console.log(`  Content: ${truncate(mem.content, 60)}`);
+                console.log("  " + "-".repeat(40));
+            }
+        }
+        console.log("");
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error fetching shared memories:", error);
+        await pressEnterToContinue();
+    }
+}
+async function boostMemory(config) {
+    try {
+        const id = await input({
+            message: "Memory ID to boost:",
+            validate: (v) => (v.length > 0 ? true : "ID is required"),
+        });
+        const res = await fetch(`${config.apiUrl}/api/brain/boost/${id}`, {
+            method: "POST",
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            console.error(`\n  Error: ${error}\n`);
+        }
+        else {
+            console.log(`\n  Memory boosted!\n`);
+        }
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error boosting memory:", error);
+        await pressEnterToContinue();
+    }
+}
+async function archiveMemory(config) {
+    try {
+        const id = await input({
+            message: "Memory ID to archive:",
+            validate: (v) => (v.length > 0 ? true : "ID is required"),
+        });
+        const confirmed = await confirm({
+            message: "Are you sure you want to archive this memory?",
+            default: false,
+        });
+        if (!confirmed) {
+            console.log("\n  Cancelled.\n");
+            await pressEnterToContinue();
+            return;
+        }
+        const res = await fetch(`${config.apiUrl}/api/brain/archive/${id}`, {
+            method: "POST",
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            console.error(`\n  Error: ${error}\n`);
+        }
+        else {
+            console.log(`\n  Memory archived!\n`);
+        }
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error archiving memory:", error);
+        await pressEnterToContinue();
+    }
+}
+async function deleteMemory(config) {
+    try {
+        const id = await input({
+            message: "Memory ID to delete:",
+            validate: (v) => (v.length > 0 ? true : "ID is required"),
+        });
+        const confirmed = await confirm({
+            message: "Are you sure you want to DELETE this memory? This cannot be undone.",
+            default: false,
+        });
+        if (!confirmed) {
+            console.log("\n  Cancelled.\n");
+            await pressEnterToContinue();
+            return;
+        }
+        const res = await fetch(`${config.apiUrl}/api/brain/memories/${id}`, {
+            method: "DELETE",
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            console.error(`\n  Error: ${error}\n`);
+        }
+        else {
+            console.log(`\n  Memory deleted!\n`);
+        }
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error deleting memory:", error);
+        await pressEnterToContinue();
+    }
+}
+async function cleanupMemories(config) {
+    try {
+        const confirmed = await confirm({
+            message: "Clean up old/low-quality memories?",
+            default: false,
+        });
+        if (!confirmed) {
+            console.log("\n  Cancelled.\n");
+            await pressEnterToContinue();
+            return;
+        }
+        const res = await fetch(`${config.apiUrl}/api/brain/cleanup`, {
+            method: "POST",
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            console.error(`\n  Error: ${error}\n`);
+        }
+        else {
+            const data = await res.json();
+            console.log(`\n  Cleanup complete! Removed: ${data.removed || 0} memories\n`);
+        }
+        await pressEnterToContinue();
+    }
+    catch (error) {
+        console.error("\n  Error cleaning up:", error);
+        await pressEnterToContinue();
+    }
+}

package/dist/commands/interactive/chat.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Interactive Mode: Chat Module
+ *
+ * Provides menu-based Google Chat integration and messaging.
+ */
+export declare function chatMenu(): Promise<void>;