whale-code 6.4.0

package/README.md

@@ -0,0 +1,95 @@
+# @swagmanager/mcp
+
+MCP (Model Context Protocol) server for SwagManager — manage inventory, orders, analytics, customers, and more from Claude Code or Claude Desktop.
+
+## Setup
+
+```bash
+npm install -g @swagmanager/mcp
+```
+
+### Environment Variables
+
+Create a `.env` file or set these environment variables:
+
+```
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_SERVICE_ROLE_KEY=your-service-role-key
+DEFAULT_STORE_ID=your-store-uuid
+```
+
+### Claude Code
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "swagmanager": {
+      "command": "swagmanager-mcp",
+      "env": {
+        "SUPABASE_URL": "https://your-project.supabase.co",
+        "SUPABASE_SERVICE_ROLE_KEY": "your-key",
+        "DEFAULT_STORE_ID": "your-store-uuid"
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+Add to your Claude Desktop MCP config:
+
+```json
+{
+  "mcpServers": {
+    "swagmanager": {
+      "command": "npx",
+      "args": ["@swagmanager/mcp"],
+      "env": {
+        "SUPABASE_URL": "https://your-project.supabase.co",
+        "SUPABASE_SERVICE_ROLE_KEY": "your-key",
+        "DEFAULT_STORE_ID": "your-store-uuid"
+      }
+    }
+  }
+}
+```
+
+## Tools
+
+Tools are loaded dynamically from the `ai_tool_registry` database table. The default set includes:
+
+| Tool | Description |
+|------|-------------|
+| `analytics` | Sales analytics with flexible date ranges |
+| `inventory` | Adjust quantities, set stock, transfer between locations |
+| `inventory_query` | Query inventory summary, velocity, by location |
+| `inventory_audit` | Start, count, complete inventory audits |
+| `orders` | Find orders, get details, purchase orders |
+| `purchase_orders` | Create, approve, receive, cancel purchase orders |
+| `transfers` | Transfer inventory between locations |
+| `products` | Find, create, update products and pricing |
+| `customers` | Find, create, update customers |
+| `collections` | Manage product collections |
+| `suppliers` | Find and list suppliers |
+| `locations` | Find store locations |
+| `email` | Send emails, manage inbox |
+| `alerts` | Low stock and pending order alerts |
+| `documents` | Generate COAs and documents |
+| `audit_trail` | View audit logs |
+
+## Development
+
+```bash
+git clone https://github.com/floradistro/whale-mcp.git
+cd whale-mcp
+npm install
+cp .env.example .env  # fill in your credentials
+npm run dev
+```
+
+## License
+
+MIT

package/bin/swag-agent.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+// SwagManager Local Agent — CLI entry point
+// Usage: swag-agent start --key YOUR_API_KEY
+
+import("../dist/local-agent/index.js").catch((err) => {
+  console.error("Failed to start swag-agent:", err.message);
+  console.error("Run 'npm run build' first if you see module not found errors.");
+  process.exit(1);
+});

package/bin/swagmanager-mcp.js

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+
+/**
+ * whale code — local-first AI agent CLI
+ *
+ * Usage:
+ *   whale                        Start interactive chat
+ *   whale -p "prompt"            Non-interactive (print) mode
+ *   whale login                  Log in with SwagManager credentials
+ *   whale logout                 Clear saved session
+ *   whale status                 Show connection status
+ *   whale mcp list|add|remove    Manage MCP servers
+ *   whale doctor                 Run diagnostics
+ *   whale config [key] [value]   View/set configuration
+ *   whale help                   Show this help
+ *   (non-TTY stdin)              MCP stdio server for Claude Code / Cursor
+ */
+
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { readFileSync } from "fs";
+import { parseArgs } from "util";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const distDir = join(__dirname, "..", "dist");
+
+// Read version once — used for --version, help banner, etc.
+let PKG_VERSION = "0.0.0";
+try {
+  PKG_VERSION = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8")).version;
+} catch { /* fallback */ }
+
+// ── Parse CLI flags ──
+let parsed;
+try {
+  parsed = parseArgs({
+    allowPositionals: true,
+    strict: false,
+    options: {
+      // Print / headless mode
+      print:                  { type: "boolean", short: "p" },
+      "output-format":        { type: "string" },
+      // Model & mode
+      model:                  { type: "string", short: "m" },
+      "permission-mode":      { type: "string" },
+      // Session
+      resume:                 { type: "string", short: "r" },
+      continue:               { type: "boolean", short: "c" },
+      "session-id":           { type: "string" },
+      "no-session-persistence": { type: "boolean" },
+      // Limits
+      "max-turns":            { type: "string" },
+      "max-budget-usd":       { type: "string" },
+      effort:                 { type: "string" },
+      // Tool filtering
+      "allowed-tools":        { type: "string" },
+      "disallowed-tools":     { type: "string" },
+      // Fallback
+      "fallback-model":       { type: "string" },
+      // Serve mode
+      port:                   { type: "string" },
+      host:                   { type: "string" },
+      // Debug / verbose
+      debug:                  { type: "boolean" },
+      verbose:                { type: "boolean", short: "v" },
+      // Standard
+      help:                   { type: "boolean", short: "h" },
+      version:                { type: "boolean" },
+    },
+  });
+} catch (err) {
+  console.error(`Error: ${err.message}`);
+  console.error("Run 'whale help' for usage.");
+  process.exit(1);
+}
+
+const { values: flags, positionals } = parsed;
+
+// First positional is the subcommand (unless --print is used)
+const subcommand = positionals[0];
+// If --print, remaining positionals form the message
+const printMessage = flags.print
+  ? positionals.join(" ")
+  : undefined;
+
+// ── Help ──
+function showHelp() {
+  const d = "\x1b[2m";
+  const B = "\x1b[1m";
+  const r = "\x1b[0m";
+  const c = "\x1b[38;2;99;102;241m";
+  const g = "\x1b[38;2;100;116;139m";
+
+  console.log();
+  console.log(`  ${g}╭──────────────────────────────────────────╮${r}`);
+  console.log(`  ${g}│${r}                                          ${g}│${r}`);
+  console.log(`  ${g}│${r}   ${c}${B}◆ whale code${r}  ${d}v${PKG_VERSION}${r}                    ${g}│${r}`);
+  console.log(`  ${g}│${r}   ${d}local-first AI agent CLI${r}               ${g}│${r}`);
+  console.log(`  ${g}│${r}                                          ${g}│${r}`);
+  console.log(`  ${g}╰──────────────────────────────────────────╯${r}`);
+  console.log();
+  console.log(`  ${B}Commands:${r}`);
+  console.log(`    whale${d}                  Start chatting (default)${r}`);
+  console.log(`    whale login${d}            Log in to SwagManager${r}`);
+  console.log(`    whale logout${d}           Clear session${r}`);
+  console.log(`    whale stores${d}           Switch active store${r}`);
+  console.log(`    whale status${d}           Connection & tools${r}`);
+  console.log(`    whale setup${d}            Install MCP to IDEs${r}`);
+  console.log(`    whale mcp${d}              Manage MCP servers${r}`);
+  console.log(`    whale doctor${d}           Run diagnostics${r}`);
+  console.log(`    whale init${d}             Generate .whale/CLAUDE.md for project${r}`);
+  console.log(`    whale config${d}           View/set configuration${r}`);
+  console.log(`    whale serve${d}            Local agent WebSocket server${r}`);
+  console.log(`    whale agent${d}            Start local security agent${r}`);
+  console.log();
+  console.log(`  ${B}Print Mode (non-interactive):${r}`);
+  console.log(`    whale -p "prompt"${d}      Run single prompt, output to stdout${r}`);
+  console.log(`    echo "prompt" | whale -p${d}  Read prompt from stdin${r}`);
+  console.log();
+  console.log(`  ${B}Flags:${r}`);
+  console.log(`    -p, --print${d}                 Non-interactive mode${r}`);
+  console.log(`    --output-format <fmt>${d}       text|json|stream-json (default: text)${r}`);
+  console.log(`    -m, --model <name>${d}          sonnet|opus|haiku${r}`);
+  console.log(`    --permission-mode <mode>${d}    default|plan|yolo${r}`);
+  console.log(`    -r, --resume <id>${d}           Resume session by ID${r}`);
+  console.log(`    -c, --continue${d}              Continue most recent session${r}`);
+  console.log(`    --session-id <id>${d}           Custom session UUID${r}`);
+  console.log(`    --no-session-persistence${d}    Ephemeral session${r}`);
+  console.log(`    --max-turns <n>${d}             Limit agent turns${r}`);
+  console.log(`    --max-budget-usd <n>${d}        Cost cap in USD${r}`);
+  console.log(`    --effort <level>${d}            low|medium|high${r}`);
+  console.log(`    --allowed-tools <list>${d}      Comma-separated tool whitelist${r}`);
+  console.log(`    --disallowed-tools <list>${d}   Comma-separated tool blacklist${r}`);
+  console.log(`    --fallback-model <name>${d}     Auto-fallback on overload${r}`);
+  console.log(`    --debug${d}                     Debug logging to stderr${r}`);
+  console.log(`    -v, --verbose${d}               Extra output${r}`);
+  console.log();
+  console.log(`  ${B}In chat:${r}`);
+  console.log(`    ${d}Type ${r}/${d} to open command menu${r}`);
+  console.log(`    ${d}^C to exit, esc to cancel${r}`);
+  console.log();
+}
+
+// Build options object from flags
+function buildOptions() {
+  return {
+    model: flags.model,
+    permissionMode: flags["permission-mode"],
+    resumeSessionId: flags.resume,
+    continueLastSession: flags.continue,
+    sessionId: flags["session-id"],
+    noSessionPersistence: flags["no-session-persistence"],
+    maxTurns: flags["max-turns"] ? parseInt(flags["max-turns"], 10) : undefined,
+    maxBudgetUsd: flags["max-budget-usd"] ? parseFloat(flags["max-budget-usd"]) : undefined,
+    effort: flags.effort,
+    allowedTools: flags["allowed-tools"]?.split(",").map(s => s.trim()),
+    disallowedTools: flags["disallowed-tools"]?.split(",").map(s => s.trim()),
+    fallbackModel: flags["fallback-model"],
+    debug: flags.debug,
+    verbose: flags.verbose,
+  };
+}
+
+// ── Version ──
+if (flags.version) {
+  console.log(PKG_VERSION);
+  process.exit(0);
+}
+
+// ── Help ──
+if (flags.help && !subcommand) {
+  showHelp();
+  process.exit(0);
+}
+
+// ── Print mode ──
+if (flags.print) {
+  const { runPrintMode } = await import(join(distDir, "cli", "print-mode.js"));
+  const options = buildOptions();
+
+  // Read stdin if available (non-TTY)
+  let stdinContent = "";
+  if (!process.stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    stdinContent = Buffer.concat(chunks).toString("utf-8").trim();
+  }
+
+  // Combine stdin + positional message
+  const message = [stdinContent, printMessage].filter(Boolean).join("\n\n");
+  if (!message) {
+    console.error("Error: --print requires a message. Provide as argument or via stdin.");
+    process.exit(1);
+  }
+
+  const exitCode = await runPrintMode({
+    message,
+    outputFormat: flags["output-format"] || "text",
+    ...options,
+  });
+  process.exit(exitCode);
+}
+
+// ── Route subcommands ──
+const command = subcommand;
+switch (command) {
+  case "help":
+  case "--help":
+  case "-h":
+    showHelp();
+    break;
+
+  case "login": {
+    if (!process.stdin.isTTY) {
+      console.error("Error: whale login requires an interactive terminal.");
+      process.exit(1);
+    }
+    const { renderLogin } = await import(join(distDir, "cli", "app.js"));
+    await renderLogin();
+    break;
+  }
+
+  case "logout": {
+    const { renderLogout } = await import(join(distDir, "cli", "app.js"));
+    await renderLogout();
+    break;
+  }
+
+  case "chat":
+  case undefined: {
+    if (process.stdin.isTTY) {
+      const { renderChat } = await import(join(distDir, "cli", "app.js"));
+      await renderChat(buildOptions());
+    } else if (command === "chat") {
+      console.error("Error: whale chat requires an interactive terminal.");
+      process.exit(1);
+    } else {
+      // Non-TTY, no command → MCP stdio server
+      await import(join(distDir, "index.js"));
+    }
+    break;
+  }
+
+  case "status": {
+    const { renderStatus } = await import(join(distDir, "cli", "app.js"));
+    await renderStatus();
+    break;
+  }
+
+  case "setup": {
+    if (!process.stdin.isTTY) {
+      console.error("Error: whale setup requires an interactive terminal.");
+      process.exit(1);
+    }
+    const { renderSetup } = await import(join(distDir, "cli", "app.js"));
+    await renderSetup();
+    break;
+  }
+
+  case "stores":
+  case "store": {
+    if (!process.stdin.isTTY) {
+      console.error("Error: whale stores requires an interactive terminal.");
+      process.exit(1);
+    }
+    const { renderStores } = await import(join(distDir, "cli", "app.js"));
+    await renderStores();
+    break;
+  }
+
+  case "mcp": {
+    const { runMcpCommand } = await import(join(distDir, "cli", "commands", "mcp.js"));
+    await runMcpCommand(positionals.slice(1));
+    break;
+  }
+
+  case "doctor": {
+    const { runDoctor } = await import(join(distDir, "cli", "commands", "doctor.js"));
+    await runDoctor();
+    break;
+  }
+
+  case "config": {
+    const { runConfigCommand } = await import(join(distDir, "cli", "commands", "config-cmd.js"));
+    await runConfigCommand(positionals.slice(1), flags);
+    break;
+  }
+
+  case "init": {
+    const { runInit } = await import(join(distDir, "cli", "commands", "init.js"));
+    await runInit();
+    break;
+  }
+
+  case "serve": {
+    const { runServeMode } = await import(join(distDir, "cli", "serve-mode.js"));
+    await runServeMode({
+      port: flags.port ? parseInt(flags.port, 10) : 3847,
+      host: flags.host || "127.0.0.1",
+      ...buildOptions(),
+    });
+    break;
+  }
+
+  case "agent": {
+    // Forward remaining args to local-agent CLI
+    // Rebuild process.argv so the agent sees: [node, script, subcommand, ...flags]
+    const agentArgs = process.argv.slice(2).filter(a => a !== "agent");
+    process.argv = [process.argv[0], process.argv[1], ...agentArgs];
+    await import(join(distDir, "local-agent", "index.js"));
+    break;
+  }
+
+  default:
+    console.error(`Unknown command: ${command}`);
+    console.error(`Run 'whale help' for usage.`);
+    process.exit(1);
+}

package/dist/cli/app.d.ts

@@ -0,0 +1,26 @@
+/**
+ * CLI App Entry Point
+ *
+ * Dynamic imports for each mode — keeps MCP server path clean.
+ */
+export interface ChatOptions {
+    model?: string;
+    permissionMode?: string;
+    resumeSessionId?: string;
+    continueLastSession?: boolean;
+    sessionId?: string;
+    maxTurns?: number;
+    maxBudgetUsd?: number;
+    effort?: string;
+    allowedTools?: string[];
+    disallowedTools?: string[];
+    fallbackModel?: string;
+    debug?: boolean;
+    verbose?: boolean;
+}
+export declare function renderLogin(): Promise<void>;
+export declare function renderLogout(): Promise<void>;
+export declare function renderChat(options?: ChatOptions): Promise<void>;
+export declare function renderSetup(): Promise<void>;
+export declare function renderStatus(): Promise<void>;
+export declare function renderStores(): Promise<void>;

package/dist/cli/app.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { initErrorLogger, setErrorLoggerUser, captureError } from "./services/error-logger.js";
+import { loadConfig } from "./services/config-store.js";
+export async function renderLogin() {
+    const { LoginApp } = await import("./login/LoginApp.js");
+    const { waitUntilExit } = render(_jsx(LoginApp, {}));
+    await waitUntilExit();
+}
+export async function renderLogout() {
+    const { signOut, isLoggedIn } = await import("./services/auth-service.js");
+    if (!isLoggedIn()) {
+        console.log("Not logged in.");
+    }
+    else {
+        signOut();
+        console.log("Logged out. Tokens cleared.");
+    }
+}
+export async function renderChat(options) {
+    // Initialize error logging before anything else
+    initErrorLogger({ serviceName: "whale-code" });
+    const cfg = loadConfig();
+    if (cfg.user_id || cfg.email || cfg.store_id) {
+        setErrorLoggerUser(cfg.user_id, cfg.email, cfg.store_id);
+    }
+    // Global handlers — catch anything that slips through
+    process.on("uncaughtException", (err) => {
+        captureError({ error: err, severity: "fatal", tags: { source: "uncaughtException" } });
+    });
+    process.on("unhandledRejection", (reason) => {
+        const err = reason instanceof Error ? reason : new Error(String(reason));
+        captureError({ error: err, severity: "error", tags: { source: "unhandledRejection" } });
+    });
+    const { matrixIntro } = await import("./shared/MatrixIntro.js");
+    await matrixIntro();
+    // Apply options before starting chat
+    if (options?.model || options?.permissionMode) {
+        const agentLoop = await import("./services/agent-loop.js");
+        if (options.model)
+            agentLoop.setModel(options.model);
+        if (options.permissionMode) {
+            agentLoop.setPermissionMode(options.permissionMode);
+        }
+    }
+    const { ChatApp } = await import("./chat/ChatApp.js");
+    const { waitUntilExit } = render(_jsx(ChatApp, {}));
+    await waitUntilExit();
+}
+export async function renderSetup() {
+    const { SetupApp } = await import("./setup/SetupApp.js");
+    const { waitUntilExit } = render(_jsx(SetupApp, {}));
+    await waitUntilExit();
+}
+export async function renderStatus() {
+    const { StatusApp } = await import("./status/StatusApp.js");
+    const { waitUntilExit } = render(_jsx(StatusApp, {}));
+    await waitUntilExit();
+}
+export async function renderStores() {
+    const { StoreApp } = await import("./stores/StoreApp.js");
+    const { waitUntilExit } = render(_jsx(StoreApp, {}));
+    await waitUntilExit();
+}

package/dist/cli/chat/AgentSelector.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AgentSelector — polished agent picker with descriptions
+ */
+interface Agent {
+    id: string;
+    name: string;
+    model: string;
+}
+interface AgentSelectorProps {
+    agents: Agent[];
+    onSelect: (agentId: string) => void;
+}
+export declare function AgentSelector({ agents, onSelect }: AgentSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cli/chat/AgentSelector.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import SelectInput from "ink-select-input";
+import { colors, symbols } from "../shared/Theme.js";
+export function AgentSelector({ agents, onSelect }) {
+    const items = agents.map((a) => ({
+        label: `${a.name}`,
+        value: a.id,
+    }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: colors.muted, children: "Select an agent:" }), _jsx(Box, { height: 1 }), _jsx(SelectInput, { items: items, onSelect: (item) => onSelect(item.value), indicatorComponent: ({ isSelected }) => (_jsxs(Text, { color: isSelected ? colors.brand : colors.dim, children: [isSelected ? symbols.arrowRight : " ", " "] })), itemComponent: ({ isSelected, label }) => {
+                    const agent = agents.find((a) => a.name === label);
+                    return (_jsxs(Box, { children: [_jsx(Text, { color: isSelected ? colors.brand : colors.text, bold: isSelected, children: label }), agent && (_jsxs(Text, { color: colors.dim, children: [" (", agent.model, ")"] }))] }));
+                } })] }));
+}

package/dist/cli/chat/ChatApp.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ChatApp — whale code CLI
+ *
+ * Uses Ink's <Static> for completed messages — written to stdout once,
+ * never re-rendered. Only the active area (streaming, tools, input)
+ * is managed by Ink's render loop. This prevents scroll bounce when
+ * content exceeds the terminal height.
+ */
+export declare function ChatApp(): import("react/jsx-runtime").JSX.Element;