@hailer/mcp 0.0.5 → 0.1.0

package/dist/mcp/utils/tool-helpers.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Tool Helper Utilities
+ *
+ * Centralized utilities for common tool operations to reduce code duplication.
+ */
+import { UserContext } from '../UserContextCache';
+import { WorkspaceCache } from '../workspace-cache';
+import { McpResponse } from './types';
+/**
+ * Error thrown when workspace cache is not available
+ */
+export declare class MissingWorkspaceCacheError extends Error {
+    constructor();
+}
+/**
+ * Requires workspace cache to be available, throws if not.
+ * Use this when workspace cache is mandatory for the operation.
+ *
+ * @example
+ * ```typescript
+ * const cache = requireWorkspaceCache(context);
+ * // cache is guaranteed to be non-null here
+ * ```
+ */
+export declare function requireWorkspaceCache(context: UserContext): WorkspaceCache;
+/**
+ * Creates a standard error response for missing workspace cache.
+ * Use this for tools that need workspace cache but want to return an error response
+ * instead of throwing.
+ */
+export declare function missingWorkspaceCacheResponse(): McpResponse;
+/**
+ * Gets the resolved workspace ID from args or defaults to current workspace.
+ * Combines workspace cache check and ID resolution into one call.
+ *
+ * @param args - Arguments object that may contain workspaceId
+ * @param context - User context with workspace cache
+ * @returns Resolved workspace ID or undefined if cache unavailable
+ *
+ * @example
+ * ```typescript
+ * const workspaceId = getResolvedWorkspaceId(args, context);
+ * if (!workspaceId) {
+ *   return missingWorkspaceCacheResponse();
+ * }
+ * ```
+ */
+export declare function getResolvedWorkspaceId(args: {
+    workspaceId?: string;
+}, context: UserContext): string | undefined;
+/**
+ * Gets the resolved workspace ID, throwing if workspace cache is unavailable.
+ * Use this when workspace cache is mandatory for the operation.
+ *
+ * @param args - Arguments object that may contain workspaceId
+ * @param context - User context with workspace cache
+ * @returns Resolved workspace ID (guaranteed non-undefined)
+ * @throws MissingWorkspaceCacheError if workspace cache is unavailable
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const workspaceId = getRequiredWorkspaceId(args, context);
+ *   // workspaceId is guaranteed to be a string
+ * } catch (error) {
+ *   if (error instanceof MissingWorkspaceCacheError) {
+ *     return missingWorkspaceCacheResponse();
+ *   }
+ *   throw error;
+ * }
+ * ```
+ */
+export declare function getRequiredWorkspaceId(args: {
+    workspaceId?: string;
+}, context: UserContext): string;
+/**
+ * Extracts a human-readable error message from an unknown error.
+ * Handles Error instances, objects with message properties, and primitives.
+ *
+ * @param error - The error to extract message from
+ * @returns Human-readable error message string
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await someOperation();
+ * } catch (error) {
+ *   const message = extractErrorMessage(error);
+ *   return errorResponse(`Operation failed: ${message}`);
+ * }
+ * ```
+ */
+export declare function extractErrorMessage(error: unknown): string;
+/**
+ * Creates a standard success response with formatted text.
+ */
+export declare function successResponse(text: string): McpResponse;
+/**
+ * Creates a standard error response with formatted text.
+ */
+export declare function errorResponse(text: string): McpResponse;
+//# sourceMappingURL=tool-helpers.d.ts.map

package/dist/mcp/utils/tool-helpers.js

@@ -0,0 +1,179 @@
+"use strict";
+/**
+ * Tool Helper Utilities
+ *
+ * Centralized utilities for common tool operations to reduce code duplication.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingWorkspaceCacheError = void 0;
+exports.requireWorkspaceCache = requireWorkspaceCache;
+exports.missingWorkspaceCacheResponse = missingWorkspaceCacheResponse;
+exports.getResolvedWorkspaceId = getResolvedWorkspaceId;
+exports.getRequiredWorkspaceId = getRequiredWorkspaceId;
+exports.extractErrorMessage = extractErrorMessage;
+exports.successResponse = successResponse;
+exports.errorResponse = errorResponse;
+const workspace_cache_1 = require("../workspace-cache");
+/**
+ * Error thrown when workspace cache is not available
+ */
+class MissingWorkspaceCacheError extends Error {
+    constructor() {
+        super('Workspace cache not available');
+        this.name = 'MissingWorkspaceCacheError';
+    }
+}
+exports.MissingWorkspaceCacheError = MissingWorkspaceCacheError;
+/**
+ * Requires workspace cache to be available, throws if not.
+ * Use this when workspace cache is mandatory for the operation.
+ *
+ * @example
+ * ```typescript
+ * const cache = requireWorkspaceCache(context);
+ * // cache is guaranteed to be non-null here
+ * ```
+ */
+function requireWorkspaceCache(context) {
+    if (!context.workspaceCache) {
+        throw new MissingWorkspaceCacheError();
+    }
+    return context.workspaceCache;
+}
+/**
+ * Creates a standard error response for missing workspace cache.
+ * Use this for tools that need workspace cache but want to return an error response
+ * instead of throwing.
+ */
+function missingWorkspaceCacheResponse() {
+    return {
+        content: [{
+                type: "text",
+                text: "Workspace cache not available",
+            }],
+    };
+}
+/**
+ * Gets the resolved workspace ID from args or defaults to current workspace.
+ * Combines workspace cache check and ID resolution into one call.
+ *
+ * @param args - Arguments object that may contain workspaceId
+ * @param context - User context with workspace cache
+ * @returns Resolved workspace ID or undefined if cache unavailable
+ *
+ * @example
+ * ```typescript
+ * const workspaceId = getResolvedWorkspaceId(args, context);
+ * if (!workspaceId) {
+ *   return missingWorkspaceCacheResponse();
+ * }
+ * ```
+ */
+function getResolvedWorkspaceId(args, context) {
+    if (!context.workspaceCache) {
+        return undefined;
+    }
+    if (args.workspaceId) {
+        return (0, workspace_cache_1.resolveWorkspaceId)(context.workspaceCache, args.workspaceId);
+    }
+    return context.workspaceCache.currentWorkspace._id;
+}
+/**
+ * Gets the resolved workspace ID, throwing if workspace cache is unavailable.
+ * Use this when workspace cache is mandatory for the operation.
+ *
+ * @param args - Arguments object that may contain workspaceId
+ * @param context - User context with workspace cache
+ * @returns Resolved workspace ID (guaranteed non-undefined)
+ * @throws MissingWorkspaceCacheError if workspace cache is unavailable
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const workspaceId = getRequiredWorkspaceId(args, context);
+ *   // workspaceId is guaranteed to be a string
+ * } catch (error) {
+ *   if (error instanceof MissingWorkspaceCacheError) {
+ *     return missingWorkspaceCacheResponse();
+ *   }
+ *   throw error;
+ * }
+ * ```
+ */
+function getRequiredWorkspaceId(args, context) {
+    const cache = requireWorkspaceCache(context);
+    if (args.workspaceId) {
+        const resolved = (0, workspace_cache_1.resolveWorkspaceId)(cache, args.workspaceId);
+        if (!resolved) {
+            throw new Error(`Workspace not found: ${args.workspaceId}`);
+        }
+        return resolved;
+    }
+    return cache.currentWorkspace._id;
+}
+/**
+ * Extracts a human-readable error message from an unknown error.
+ * Handles Error instances, objects with message properties, and primitives.
+ *
+ * @param error - The error to extract message from
+ * @returns Human-readable error message string
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await someOperation();
+ * } catch (error) {
+ *   const message = extractErrorMessage(error);
+ *   return errorResponse(`Operation failed: ${message}`);
+ * }
+ * ```
+ */
+function extractErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (error && typeof error === 'object') {
+        // Check for common error object shapes
+        const errorObj = error;
+        if (typeof errorObj.message === 'string') {
+            return errorObj.message;
+        }
+        if (typeof errorObj.error === 'string') {
+            return errorObj.error;
+        }
+        if (typeof errorObj.details === 'string') {
+            return errorObj.details;
+        }
+        // Fallback to JSON representation
+        try {
+            return JSON.stringify(error, null, 2);
+        }
+        catch {
+            return String(error);
+        }
+    }
+    return String(error);
+}
+/**
+ * Creates a standard success response with formatted text.
+ */
+function successResponse(text) {
+    return {
+        content: [{
+                type: "text",
+                text,
+            }],
+    };
+}
+/**
+ * Creates a standard error response with formatted text.
+ */
+function errorResponse(text) {
+    return {
+        content: [{
+                type: "text",
+                text: `${text}`,
+            }],
+    };
+}
+//# sourceMappingURL=tool-helpers.js.map

package/dist/mcp/utils/types.d.ts

@@ -17,6 +17,10 @@ export interface HailerField {
     uid?: string;
     description?: string;
     defaultTo?: boolean;
+    key?: string;
+    subtype?: string;
+    placeholder?: string;
+    functionVariables?: any;
 }
 export interface HailerPhase {
     _id: string;
@@ -32,6 +36,8 @@ export interface HailerPhase {
     created: number;
     members: any[];
     followers: any[];
+    color?: string;
+    isInitial?: boolean;
 }
 export interface HailerTranslationField {
     label: string;

package/dist/mcp/workspace-cache.d.ts

@@ -1,4 +1,4 @@
-import { HailerV2CoreInitResponse } from "./utils/index";
+import { HailerV2CoreInitResponse, WorkspaceInfo } from "./utils/index";
 import { McpConfig } from "../config";
 export interface UserInfo {
     id: string;
@@ -6,14 +6,14 @@ export interface UserInfo {
     lastname: string;
     fullName: string;
     companies: string[];
-    default_profilepic: string;
+    default_profilepic?: string;
     lastSeen: number;
 }
 export interface WorkspaceCache {
     users: UserInfo[];
     usersById: Record<string, UserInfo>;
-    currentWorkspace: any;
-    allWorkspaces: Record<string, any>;
+    currentWorkspace: WorkspaceInfo;
+    allWorkspaces: Record<string, WorkspaceInfo>;
     workspaceNames: Record<string, string>;
     timestamp: {
         users: number;
@@ -34,7 +34,7 @@ export declare function getUserById(cache: WorkspaceCache, userId: string): User
 /**
  * Gets workspace by name (case-insensitive)
  */
-export declare function getWorkspaceByName(cache: WorkspaceCache, name: string): any;
+export declare function getWorkspaceByName(cache: WorkspaceCache, name: string): WorkspaceInfo | undefined;
 /**
  * Resolves workspace identifier (ID or name) to workspace ID
  */

package/dist/mcp/workspace-cache.js

@@ -5,7 +5,8 @@ exports.getUserById = getUserById;
 exports.getWorkspaceByName = getWorkspaceByName;
 exports.resolveWorkspaceId = resolveWorkspaceId;
 /**
- * Removes empty/default fields from an object to save context space
+ * Removes empty/default fields from an object to save context space.
+ * Returns the same type T - empty fields are removed at runtime but type stays intact.
  */
 function compactObject(obj, config) {
     if (!config.excludeEmptyFields || !obj || typeof obj !== 'object') {
@@ -49,8 +50,8 @@ function createWorkspaceCache(init, config) {
         usersById[user._id] = userInfo;
     });
     // Process workspace data
-    const currentWorkspace = init.network || {};
-    const allWorkspaces = init.networks || {};
+    const currentWorkspace = (init.network || {});
+    const allWorkspaces = (init.networks || {});
     const workspaceNames = {};
     // Build workspace name mapping
     Object.values(allWorkspaces).forEach((workspace) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hailer/mcp",
-  "version": "0.0.5",
+  "version": "0.1.0",
   "config": {
     "docker": {
       "registry": "registry.gitlab.com/hailer-repos/hailer-mcp"

package/.claude/hooks/PreToolUse.sh

@@ -1,52 +0,0 @@
-#!/bin/bash
-# Claude Code PreToolUse hook - auto-loads SDK skills before bash commands
-
-TOOL="$1"
-
-# Only process Bash tool
-if [[ "$TOOL" != "Bash" ]]; then
-  exit 0
-fi
-
-# Read tool input from stdin
-INPUT=$(cat)
-COMMAND=$(echo "$INPUT" | jq -r '.command // empty')
-
-# Marker directory for tracking loaded skills this session
-MARKER_DIR="/tmp/.claude-skills-loaded"
-mkdir -p "$MARKER_DIR"
-
-# SDK command to skill mapping
-load_skill_if_needed() {
-  local skill_name="$1"
-  local marker_file="$MARKER_DIR/$skill_name"
-  local skill_path=".claude/skills/$skill_name/SKILL.md"
-
-  if [[ ! -f "$marker_file" ]] && [[ -f "$skill_path" ]]; then
-    echo "" >&2
-    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" >&2
-    echo "📚 AUTO-LOADING SKILL: $skill_name" >&2
-    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" >&2
-    echo "" >&2
-    cat "$skill_path" >&2
-    echo "" >&2
-    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━" >&2
-    echo "" >&2
-    touch "$marker_file"
-  fi
-}
-
-# Check for SDK commands and load appropriate skills
-case "$COMMAND" in
-  *"npm run pull"*|*"npm run push"*|*"npm run workflows"*|*"npm run phases"*|*"npm run fields"*|*"npm run groups"*|*"npm run teams"*|*"npm run insights"*)
-    load_skill_if_needed "SDK-ws-config-skill"
-    ;;
-  *"npm run generate"*|*"hailer-sdk generate"*)
-    load_skill_if_needed "SDK-generate-skill"
-    ;;
-  *"hailer-sdk init"*)
-    load_skill_if_needed "SDK-init-skill"
-    ;;
-esac
-
-exit 0