{-# LANGUAGE NoFieldSelectors #-}

module Unison.MCP.Types
  ( MCP (..),
    Env (..),
    runMCP,
    ToolKind (..),
    ProjectCodeToolArguments (..),
    LibInstallToolArguments (..),
    ShareProjectSearchToolArguments (..),
    TypecheckCodeToolArguments (..),
    ShareProjectReadmeToolArguments (..),
    ListLibraryDefinitionsToolArguments (..),
    ViewDefinitionsToolArguments (..),
    SearchDefinitionsToolArguments (..),
    SearchByTypeToolArguments (..),
    DocsToolArguments (..),
    ProjectContext (..),
    ProjectContextArgument (..),
    ProjectNameArgument (..),
    ProjectDefinitionNameArgument (..),
    toToolName,
    fromToolName,
  )
where

import Control.Monad.Reader (MonadReader, ReaderT (..))
import Data.Aeson
import Data.Map qualified as Map
import Data.Proxy (Proxy (..))
import Data.Text qualified as Text
import Unison.Auth.HTTPClient (AuthenticatedHttpClient)
import Unison.Codebase (Codebase)
import Unison.Codebase.Editor.UCMVersion (UCMVersion)
import Unison.Codebase.Runtime (Runtime)
import Unison.Core.Project (ProjectBranchName (UnsafeProjectBranchName), ProjectName (UnsafeProjectName))
import Unison.MCP.Wrapper (HasInputSchema (..))
import Unison.Name (Name)
import Unison.Parser.Ann (Ann)
import Unison.Prelude
import Unison.Symbol (Symbol)
import Unison.Syntax.Name qualified as Name

data Env = Env
  { Env -> Codebase IO Symbol Ann
codebase :: Codebase IO Symbol Ann,
    Env -> Runtime Symbol
runtime :: Runtime Symbol,
    Env -> Runtime Symbol
sbRuntime :: Runtime Symbol,
    Env -> Text
ucmVersion :: UCMVersion,
    Env -> Maybe [Char]
workDir :: Maybe FilePath,
    Env -> AuthenticatedHttpClient
authenticatedHTTPClient :: AuthenticatedHttpClient
  }

newtype MCP a = MCP
  { forall a. MCP a -> ReaderT Env IO a
unMCP :: ReaderT Env IO a
  }
  deriving newtype ((forall a b. (a -> b) -> MCP a -> MCP b)
-> (forall a b. a -> MCP b -> MCP a) -> Functor MCP
forall a b. a -> MCP b -> MCP a
forall a b. (a -> b) -> MCP a -> MCP b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> MCP a -> MCP b
fmap :: forall a b. (a -> b) -> MCP a -> MCP b
$c<$ :: forall a b. a -> MCP b -> MCP a
<$ :: forall a b. a -> MCP b -> MCP a
Functor, Functor MCP
Functor MCP =>
(forall a. a -> MCP a)
-> (forall a b. MCP (a -> b) -> MCP a -> MCP b)
-> (forall a b c. (a -> b -> c) -> MCP a -> MCP b -> MCP c)
-> (forall a b. MCP a -> MCP b -> MCP b)
-> (forall a b. MCP a -> MCP b -> MCP a)
-> Applicative MCP
forall a. a -> MCP a
forall a b. MCP a -> MCP b -> MCP a
forall a b. MCP a -> MCP b -> MCP b
forall a b. MCP (a -> b) -> MCP a -> MCP b
forall a b c. (a -> b -> c) -> MCP a -> MCP b -> MCP c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> MCP a
pure :: forall a. a -> MCP a
$c<*> :: forall a b. MCP (a -> b) -> MCP a -> MCP b
<*> :: forall a b. MCP (a -> b) -> MCP a -> MCP b
$cliftA2 :: forall a b c. (a -> b -> c) -> MCP a -> MCP b -> MCP c
liftA2 :: forall a b c. (a -> b -> c) -> MCP a -> MCP b -> MCP c
$c*> :: forall a b. MCP a -> MCP b -> MCP b
*> :: forall a b. MCP a -> MCP b -> MCP b
$c<* :: forall a b. MCP a -> MCP b -> MCP a
<* :: forall a b. MCP a -> MCP b -> MCP a
Applicative, Applicative MCP
Applicative MCP =>
(forall a b. MCP a -> (a -> MCP b) -> MCP b)
-> (forall a b. MCP a -> MCP b -> MCP b)
-> (forall a. a -> MCP a)
-> Monad MCP
forall a. a -> MCP a
forall a b. MCP a -> MCP b -> MCP b
forall a b. MCP a -> (a -> MCP b) -> MCP b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall a b. MCP a -> (a -> MCP b) -> MCP b
>>= :: forall a b. MCP a -> (a -> MCP b) -> MCP b
$c>> :: forall a b. MCP a -> MCP b -> MCP b
>> :: forall a b. MCP a -> MCP b -> MCP b
$creturn :: forall a. a -> MCP a
return :: forall a. a -> MCP a
Monad, Monad MCP
Monad MCP => (forall a. IO a -> MCP a) -> MonadIO MCP
forall a. IO a -> MCP a
forall (m :: * -> *).
Monad m =>
(forall a. IO a -> m a) -> MonadIO m
$cliftIO :: forall a. IO a -> MCP a
liftIO :: forall a. IO a -> MCP a
MonadIO, MonadIO MCP
MonadIO MCP =>
(forall b. ((forall a. MCP a -> IO a) -> IO b) -> MCP b)
-> MonadUnliftIO MCP
forall b. ((forall a. MCP a -> IO a) -> IO b) -> MCP b
forall (m :: * -> *).
MonadIO m =>
(forall b. ((forall a. m a -> IO a) -> IO b) -> m b)
-> MonadUnliftIO m
$cwithRunInIO :: forall b. ((forall a. MCP a -> IO a) -> IO b) -> MCP b
withRunInIO :: forall b. ((forall a. MCP a -> IO a) -> IO b) -> MCP b
MonadUnliftIO, MonadReader Env)

runMCP :: Env -> MCP a -> IO a
runMCP :: forall a. Env -> MCP a -> IO a
runMCP Env
env (MCP ReaderT Env IO a
m) = do
  ReaderT Env IO a -> Env -> IO a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ReaderT Env IO a
m Env
env

data ToolKind
  = ProjectCodeTool
  | LibInstallTool
  | ShareProjectSearchTool
  | ShareProjectReadmeTool
  | TypecheckCodeTool
  | DocsTool
  | ListProjectDefinitionsTool
  | ListProjectLibrariesTool
  | ListLibraryDefinitionsTool
  | ViewDefinitionsTool
  | SearchDefinitionsTool
  | SearchByTypeTool
  | ListLocalProjectsTool
  | ListProjectBranchesTool
  | GetCurrentProjectContextTool
  | DependenciesTool
  | DependentsTool
  deriving (ToolKind -> ToolKind -> Bool
(ToolKind -> ToolKind -> Bool)
-> (ToolKind -> ToolKind -> Bool) -> Eq ToolKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ToolKind -> ToolKind -> Bool
== :: ToolKind -> ToolKind -> Bool
$c/= :: ToolKind -> ToolKind -> Bool
/= :: ToolKind -> ToolKind -> Bool
Eq, Eq ToolKind
Eq ToolKind =>
(ToolKind -> ToolKind -> Ordering)
-> (ToolKind -> ToolKind -> Bool)
-> (ToolKind -> ToolKind -> Bool)
-> (ToolKind -> ToolKind -> Bool)
-> (ToolKind -> ToolKind -> Bool)
-> (ToolKind -> ToolKind -> ToolKind)
-> (ToolKind -> ToolKind -> ToolKind)
-> Ord ToolKind
ToolKind -> ToolKind -> Bool
ToolKind -> ToolKind -> Ordering
ToolKind -> ToolKind -> ToolKind
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ToolKind -> ToolKind -> Ordering
compare :: ToolKind -> ToolKind -> Ordering
$c< :: ToolKind -> ToolKind -> Bool
< :: ToolKind -> ToolKind -> Bool
$c<= :: ToolKind -> ToolKind -> Bool
<= :: ToolKind -> ToolKind -> Bool
$c> :: ToolKind -> ToolKind -> Bool
> :: ToolKind -> ToolKind -> Bool
$c>= :: ToolKind -> ToolKind -> Bool
>= :: ToolKind -> ToolKind -> Bool
$cmax :: ToolKind -> ToolKind -> ToolKind
max :: ToolKind -> ToolKind -> ToolKind
$cmin :: ToolKind -> ToolKind -> ToolKind
min :: ToolKind -> ToolKind -> ToolKind
Ord, Int -> ToolKind -> ShowS
[ToolKind] -> ShowS
ToolKind -> [Char]
(Int -> ToolKind -> ShowS)
-> (ToolKind -> [Char]) -> ([ToolKind] -> ShowS) -> Show ToolKind
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ToolKind -> ShowS
showsPrec :: Int -> ToolKind -> ShowS
$cshow :: ToolKind -> [Char]
show :: ToolKind -> [Char]
$cshowList :: [ToolKind] -> ShowS
showList :: [ToolKind] -> ShowS
Show, ToolKind
ToolKind -> ToolKind -> Bounded ToolKind
forall a. a -> a -> Bounded a
$cminBound :: ToolKind
minBound :: ToolKind
$cmaxBound :: ToolKind
maxBound :: ToolKind
Bounded, Int -> ToolKind
ToolKind -> Int
ToolKind -> [ToolKind]
ToolKind -> ToolKind
ToolKind -> ToolKind -> [ToolKind]
ToolKind -> ToolKind -> ToolKind -> [ToolKind]
(ToolKind -> ToolKind)
-> (ToolKind -> ToolKind)
-> (Int -> ToolKind)
-> (ToolKind -> Int)
-> (ToolKind -> [ToolKind])
-> (ToolKind -> ToolKind -> [ToolKind])
-> (ToolKind -> ToolKind -> [ToolKind])
-> (ToolKind -> ToolKind -> ToolKind -> [ToolKind])
-> Enum ToolKind
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ToolKind -> ToolKind
succ :: ToolKind -> ToolKind
$cpred :: ToolKind -> ToolKind
pred :: ToolKind -> ToolKind
$ctoEnum :: Int -> ToolKind
toEnum :: Int -> ToolKind
$cfromEnum :: ToolKind -> Int
fromEnum :: ToolKind -> Int
$cenumFrom :: ToolKind -> [ToolKind]
enumFrom :: ToolKind -> [ToolKind]
$cenumFromThen :: ToolKind -> ToolKind -> [ToolKind]
enumFromThen :: ToolKind -> ToolKind -> [ToolKind]
$cenumFromTo :: ToolKind -> ToolKind -> [ToolKind]
enumFromTo :: ToolKind -> ToolKind -> [ToolKind]
$cenumFromThenTo :: ToolKind -> ToolKind -> ToolKind -> [ToolKind]
enumFromThenTo :: ToolKind -> ToolKind -> ToolKind -> [ToolKind]
Enum)

kindNameMapping :: Map ToolKind Text
kindNameMapping :: Map ToolKind Text
kindNameMapping =
  [(ToolKind, Text)] -> Map ToolKind Text
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
    [ (ToolKind
ProjectCodeTool, Text
"project-code"),
      (ToolKind
LibInstallTool, Text
"lib-install"),
      (ToolKind
ShareProjectSearchTool, Text
"share-project-search"),
      (ToolKind
ShareProjectReadmeTool, Text
"share-project-readme"),
      (ToolKind
TypecheckCodeTool, Text
"typecheck-code"),
      (ToolKind
DocsTool, Text
"docs"),
      (ToolKind
ListProjectDefinitionsTool, Text
"list-project-definitions"),
      (ToolKind
ListProjectLibrariesTool, Text
"list-project-libraries"),
      (ToolKind
ListLibraryDefinitionsTool, Text
"list-library-definitions"),
      (ToolKind
ViewDefinitionsTool, Text
"view-definitions"),
      (ToolKind
SearchDefinitionsTool, Text
"search-definitions-by-name"),
      (ToolKind
SearchByTypeTool, Text
"search-by-type"),
      (ToolKind
ListLocalProjectsTool, Text
"list-local-projects"),
      (ToolKind
ListProjectBranchesTool, Text
"list-project-branches"),
      (ToolKind
GetCurrentProjectContextTool, Text
"get-current-project-context"),
      (ToolKind
DependenciesTool, Text
"list-definition-dependencies"),
      (ToolKind
DependentsTool, Text
"list-definition-dependents")
    ]

data ProjectDefinitionNameArgument = ProjectDefinitionNameArgument
  { ProjectDefinitionNameArgument -> Name
definitionName :: Name,
    ProjectDefinitionNameArgument -> ProjectContext
projectContext :: ProjectContext
  }
  deriving (ProjectDefinitionNameArgument
-> ProjectDefinitionNameArgument -> Bool
(ProjectDefinitionNameArgument
 -> ProjectDefinitionNameArgument -> Bool)
-> (ProjectDefinitionNameArgument
    -> ProjectDefinitionNameArgument -> Bool)
-> Eq ProjectDefinitionNameArgument
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectDefinitionNameArgument
-> ProjectDefinitionNameArgument -> Bool
== :: ProjectDefinitionNameArgument
-> ProjectDefinitionNameArgument -> Bool
$c/= :: ProjectDefinitionNameArgument
-> ProjectDefinitionNameArgument -> Bool
/= :: ProjectDefinitionNameArgument
-> ProjectDefinitionNameArgument -> Bool
Eq, Int -> ProjectDefinitionNameArgument -> ShowS
[ProjectDefinitionNameArgument] -> ShowS
ProjectDefinitionNameArgument -> [Char]
(Int -> ProjectDefinitionNameArgument -> ShowS)
-> (ProjectDefinitionNameArgument -> [Char])
-> ([ProjectDefinitionNameArgument] -> ShowS)
-> Show ProjectDefinitionNameArgument
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectDefinitionNameArgument -> ShowS
showsPrec :: Int -> ProjectDefinitionNameArgument -> ShowS
$cshow :: ProjectDefinitionNameArgument -> [Char]
show :: ProjectDefinitionNameArgument -> [Char]
$cshowList :: [ProjectDefinitionNameArgument] -> ShowS
showList :: [ProjectDefinitionNameArgument] -> ShowS
Show)

instance HasInputSchema ProjectDefinitionNameArgument where
  toInputSchema :: Proxy ProjectDefinitionNameArgument -> Value
toInputSchema Proxy ProjectDefinitionNameArgument
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
            [ Key
"definitionName"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The name of the definition to work with, e.g. `mynamespace.foo` or `lib.unison_base_1_0_0.data.List`." :: Text)
                  ],
              Key
"projectContext" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Proxy ProjectContext -> Value
forall {k} (arg :: k). HasInputSchema arg => Proxy arg -> Value
toInputSchema (Proxy ProjectContext
forall {k} (t :: k). Proxy t
Proxy :: Proxy ProjectContext)
            ],
        Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"definitionName", Text
"projectContext" :: Text]
      ]

instance FromJSON ProjectDefinitionNameArgument where
  parseJSON :: Value -> Parser ProjectDefinitionNameArgument
parseJSON = [Char]
-> (Object -> Parser ProjectDefinitionNameArgument)
-> Value
-> Parser ProjectDefinitionNameArgument
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"ProjectDefinitionNameArgument" ((Object -> Parser ProjectDefinitionNameArgument)
 -> Value -> Parser ProjectDefinitionNameArgument)
-> (Object -> Parser ProjectDefinitionNameArgument)
-> Value
-> Parser ProjectDefinitionNameArgument
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    Text
definitionNameText <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"definitionName"
    Name
definitionName <- case Text -> Either Text Name
Name.parseTextEither Text
definitionNameText of
      Left Text
err -> [Char] -> Parser Name
forall a. [Char] -> Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> Parser Name) -> [Char] -> Parser Name
forall a b. (a -> b) -> a -> b
$ [Char]
"Invalid definition name: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
err
      Right Name
definitionName -> Name -> Parser Name
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Name
definitionName
    ProjectContext
projectContext <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    ProjectDefinitionNameArgument
-> Parser ProjectDefinitionNameArgument
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ProjectDefinitionNameArgument
 -> Parser ProjectDefinitionNameArgument)
-> ProjectDefinitionNameArgument
-> Parser ProjectDefinitionNameArgument
forall a b. (a -> b) -> a -> b
$ ProjectDefinitionNameArgument {Name
$sel:definitionName:ProjectDefinitionNameArgument :: Name
definitionName :: Name
definitionName, ProjectContext
$sel:projectContext:ProjectDefinitionNameArgument :: ProjectContext
projectContext :: ProjectContext
projectContext}

newtype ProjectContextArgument = ProjectContextArgument ProjectContext
  deriving newtype (ProjectContextArgument -> ProjectContextArgument -> Bool
(ProjectContextArgument -> ProjectContextArgument -> Bool)
-> (ProjectContextArgument -> ProjectContextArgument -> Bool)
-> Eq ProjectContextArgument
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectContextArgument -> ProjectContextArgument -> Bool
== :: ProjectContextArgument -> ProjectContextArgument -> Bool
$c/= :: ProjectContextArgument -> ProjectContextArgument -> Bool
/= :: ProjectContextArgument -> ProjectContextArgument -> Bool
Eq, Int -> ProjectContextArgument -> ShowS
[ProjectContextArgument] -> ShowS
ProjectContextArgument -> [Char]
(Int -> ProjectContextArgument -> ShowS)
-> (ProjectContextArgument -> [Char])
-> ([ProjectContextArgument] -> ShowS)
-> Show ProjectContextArgument
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectContextArgument -> ShowS
showsPrec :: Int -> ProjectContextArgument -> ShowS
$cshow :: ProjectContextArgument -> [Char]
show :: ProjectContextArgument -> [Char]
$cshowList :: [ProjectContextArgument] -> ShowS
showList :: [ProjectContextArgument] -> ShowS
Show)

instance HasInputSchema ProjectContextArgument where
  toInputSchema :: Proxy ProjectContextArgument -> Value
toInputSchema Proxy ProjectContextArgument
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Proxy ProjectContext -> Value
forall {k} (arg :: k). HasInputSchema arg => Proxy arg -> Value
toInputSchema (Proxy ProjectContext
forall {k} (t :: k). Proxy t
Proxy :: Proxy ProjectContext)
            ],
        Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"projectContext" :: Text]
      ]

instance FromJSON ProjectContextArgument where
  parseJSON :: Value -> Parser ProjectContextArgument
parseJSON = [Char]
-> (Object -> Parser ProjectContextArgument)
-> Value
-> Parser ProjectContextArgument
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"ProjectContextArgument" ((Object -> Parser ProjectContextArgument)
 -> Value -> Parser ProjectContextArgument)
-> (Object -> Parser ProjectContextArgument)
-> Value
-> Parser ProjectContextArgument
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    ProjectContext
projectContext <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    ProjectContextArgument -> Parser ProjectContextArgument
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ProjectContextArgument -> Parser ProjectContextArgument)
-> ProjectContextArgument -> Parser ProjectContextArgument
forall a b. (a -> b) -> a -> b
$ ProjectContext -> ProjectContextArgument
ProjectContextArgument ProjectContext
projectContext

data ProjectNameArgument = ProjectNameArgument
  { ProjectNameArgument -> ProjectName
projectName :: ProjectName
  }
  deriving (ProjectNameArgument -> ProjectNameArgument -> Bool
(ProjectNameArgument -> ProjectNameArgument -> Bool)
-> (ProjectNameArgument -> ProjectNameArgument -> Bool)
-> Eq ProjectNameArgument
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectNameArgument -> ProjectNameArgument -> Bool
== :: ProjectNameArgument -> ProjectNameArgument -> Bool
$c/= :: ProjectNameArgument -> ProjectNameArgument -> Bool
/= :: ProjectNameArgument -> ProjectNameArgument -> Bool
Eq, Int -> ProjectNameArgument -> ShowS
[ProjectNameArgument] -> ShowS
ProjectNameArgument -> [Char]
(Int -> ProjectNameArgument -> ShowS)
-> (ProjectNameArgument -> [Char])
-> ([ProjectNameArgument] -> ShowS)
-> Show ProjectNameArgument
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectNameArgument -> ShowS
showsPrec :: Int -> ProjectNameArgument -> ShowS
$cshow :: ProjectNameArgument -> [Char]
show :: ProjectNameArgument -> [Char]
$cshowList :: [ProjectNameArgument] -> ShowS
showList :: [ProjectNameArgument] -> ShowS
Show)

instance HasInputSchema ProjectNameArgument where
  toInputSchema :: Proxy ProjectNameArgument -> Value
toInputSchema Proxy ProjectNameArgument
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
            [ Key
"projectName"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The name of a project to work within, e.g. `@unison/base` or `@ceedubs/json`" :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"projectName" :: Text]
      ]

instance FromJSON ProjectNameArgument where
  parseJSON :: Value -> Parser ProjectNameArgument
parseJSON = [Char]
-> (Object -> Parser ProjectNameArgument)
-> Value
-> Parser ProjectNameArgument
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"ProjectNameArgument" ((Object -> Parser ProjectNameArgument)
 -> Value -> Parser ProjectNameArgument)
-> (Object -> Parser ProjectNameArgument)
-> Value
-> Parser ProjectNameArgument
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    ProjectName
projectName <- Text -> ProjectName
UnsafeProjectName (Text -> ProjectName) -> Parser Text -> Parser ProjectName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectName"
    ProjectNameArgument -> Parser ProjectNameArgument
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ProjectNameArgument -> Parser ProjectNameArgument)
-> ProjectNameArgument -> Parser ProjectNameArgument
forall a b. (a -> b) -> a -> b
$ ProjectNameArgument {ProjectName
$sel:projectName:ProjectNameArgument :: ProjectName
projectName :: ProjectName
projectName}

data SearchByTypeToolArguments = SearchByTypeToolArguments
  { SearchByTypeToolArguments -> ProjectContext
projectContext :: ProjectContext,
    SearchByTypeToolArguments -> Text
query :: Text
  }
  deriving (SearchByTypeToolArguments -> SearchByTypeToolArguments -> Bool
(SearchByTypeToolArguments -> SearchByTypeToolArguments -> Bool)
-> (SearchByTypeToolArguments -> SearchByTypeToolArguments -> Bool)
-> Eq SearchByTypeToolArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SearchByTypeToolArguments -> SearchByTypeToolArguments -> Bool
== :: SearchByTypeToolArguments -> SearchByTypeToolArguments -> Bool
$c/= :: SearchByTypeToolArguments -> SearchByTypeToolArguments -> Bool
/= :: SearchByTypeToolArguments -> SearchByTypeToolArguments -> Bool
Eq, Int -> SearchByTypeToolArguments -> ShowS
[SearchByTypeToolArguments] -> ShowS
SearchByTypeToolArguments -> [Char]
(Int -> SearchByTypeToolArguments -> ShowS)
-> (SearchByTypeToolArguments -> [Char])
-> ([SearchByTypeToolArguments] -> ShowS)
-> Show SearchByTypeToolArguments
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SearchByTypeToolArguments -> ShowS
showsPrec :: Int -> SearchByTypeToolArguments -> ShowS
$cshow :: SearchByTypeToolArguments -> [Char]
show :: SearchByTypeToolArguments -> [Char]
$cshowList :: [SearchByTypeToolArguments] -> ShowS
showList :: [SearchByTypeToolArguments] -> ShowS
Show)

instance HasInputSchema SearchByTypeToolArguments where
  toInputSchema :: Proxy SearchByTypeToolArguments -> Value
toInputSchema Proxy SearchByTypeToolArguments
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Proxy ProjectContext -> Value
forall {k} (arg :: k). HasInputSchema arg => Proxy arg -> Value
toInputSchema (Proxy ProjectContext
forall {k} (t :: k). Proxy t
Proxy :: Proxy ProjectContext),
              Key
"query"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"A type to search for, e.g. `[Nat] -> Nat`." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"projectContext", Text
"query" :: Text]
      ]

instance FromJSON SearchByTypeToolArguments where
  parseJSON :: Value -> Parser SearchByTypeToolArguments
parseJSON = [Char]
-> (Object -> Parser SearchByTypeToolArguments)
-> Value
-> Parser SearchByTypeToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"SearchByTypeToolArguments" ((Object -> Parser SearchByTypeToolArguments)
 -> Value -> Parser SearchByTypeToolArguments)
-> (Object -> Parser SearchByTypeToolArguments)
-> Value
-> Parser SearchByTypeToolArguments
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    ProjectContext
projectContext <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    Text
query <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
    SearchByTypeToolArguments -> Parser SearchByTypeToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SearchByTypeToolArguments -> Parser SearchByTypeToolArguments)
-> SearchByTypeToolArguments -> Parser SearchByTypeToolArguments
forall a b. (a -> b) -> a -> b
$ SearchByTypeToolArguments {ProjectContext
$sel:projectContext:SearchByTypeToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, Text
$sel:query:SearchByTypeToolArguments :: Text
query :: Text
query}

data SearchDefinitionsToolArguments = SearchDefinitionsToolArguments
  { SearchDefinitionsToolArguments -> ProjectContext
projectContext :: ProjectContext,
    SearchDefinitionsToolArguments -> Text
query :: Text
  }
  deriving (SearchDefinitionsToolArguments
-> SearchDefinitionsToolArguments -> Bool
(SearchDefinitionsToolArguments
 -> SearchDefinitionsToolArguments -> Bool)
-> (SearchDefinitionsToolArguments
    -> SearchDefinitionsToolArguments -> Bool)
-> Eq SearchDefinitionsToolArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SearchDefinitionsToolArguments
-> SearchDefinitionsToolArguments -> Bool
== :: SearchDefinitionsToolArguments
-> SearchDefinitionsToolArguments -> Bool
$c/= :: SearchDefinitionsToolArguments
-> SearchDefinitionsToolArguments -> Bool
/= :: SearchDefinitionsToolArguments
-> SearchDefinitionsToolArguments -> Bool
Eq, Int -> SearchDefinitionsToolArguments -> ShowS
[SearchDefinitionsToolArguments] -> ShowS
SearchDefinitionsToolArguments -> [Char]
(Int -> SearchDefinitionsToolArguments -> ShowS)
-> (SearchDefinitionsToolArguments -> [Char])
-> ([SearchDefinitionsToolArguments] -> ShowS)
-> Show SearchDefinitionsToolArguments
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SearchDefinitionsToolArguments -> ShowS
showsPrec :: Int -> SearchDefinitionsToolArguments -> ShowS
$cshow :: SearchDefinitionsToolArguments -> [Char]
show :: SearchDefinitionsToolArguments -> [Char]
$cshowList :: [SearchDefinitionsToolArguments] -> ShowS
showList :: [SearchDefinitionsToolArguments] -> ShowS
Show)

instance HasInputSchema SearchDefinitionsToolArguments where
  toInputSchema :: Proxy SearchDefinitionsToolArguments -> Value
toInputSchema Proxy SearchDefinitionsToolArguments
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Proxy ProjectContext -> Value
forall {k} (arg :: k). HasInputSchema arg => Proxy arg -> Value
toInputSchema (Proxy ProjectContext
forall {k} (t :: k). Proxy t
Proxy :: Proxy ProjectContext),
              Key
"query"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"A name to search for, e.g. `foldl`." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"projectContext", Text
"query" :: Text]
      ]

instance FromJSON SearchDefinitionsToolArguments where
  parseJSON :: Value -> Parser SearchDefinitionsToolArguments
parseJSON = [Char]
-> (Object -> Parser SearchDefinitionsToolArguments)
-> Value
-> Parser SearchDefinitionsToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"SearchDefinitionsToolArguments" ((Object -> Parser SearchDefinitionsToolArguments)
 -> Value -> Parser SearchDefinitionsToolArguments)
-> (Object -> Parser SearchDefinitionsToolArguments)
-> Value
-> Parser SearchDefinitionsToolArguments
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    ProjectContext
projectContext <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    Text
query <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
    SearchDefinitionsToolArguments
-> Parser SearchDefinitionsToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SearchDefinitionsToolArguments
 -> Parser SearchDefinitionsToolArguments)
-> SearchDefinitionsToolArguments
-> Parser SearchDefinitionsToolArguments
forall a b. (a -> b) -> a -> b
$ SearchDefinitionsToolArguments {ProjectContext
$sel:projectContext:SearchDefinitionsToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, Text
$sel:query:SearchDefinitionsToolArguments :: Text
query :: Text
query}

data ViewDefinitionsToolArguments = ViewDefinitionsToolArguments
  { ViewDefinitionsToolArguments -> ProjectContext
projectContext :: ProjectContext,
    ViewDefinitionsToolArguments -> [Name]
names :: [Name]
  }
  deriving (ViewDefinitionsToolArguments
-> ViewDefinitionsToolArguments -> Bool
(ViewDefinitionsToolArguments
 -> ViewDefinitionsToolArguments -> Bool)
-> (ViewDefinitionsToolArguments
    -> ViewDefinitionsToolArguments -> Bool)
-> Eq ViewDefinitionsToolArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ViewDefinitionsToolArguments
-> ViewDefinitionsToolArguments -> Bool
== :: ViewDefinitionsToolArguments
-> ViewDefinitionsToolArguments -> Bool
$c/= :: ViewDefinitionsToolArguments
-> ViewDefinitionsToolArguments -> Bool
/= :: ViewDefinitionsToolArguments
-> ViewDefinitionsToolArguments -> Bool
Eq, Int -> ViewDefinitionsToolArguments -> ShowS
[ViewDefinitionsToolArguments] -> ShowS
ViewDefinitionsToolArguments -> [Char]
(Int -> ViewDefinitionsToolArguments -> ShowS)
-> (ViewDefinitionsToolArguments -> [Char])
-> ([ViewDefinitionsToolArguments] -> ShowS)
-> Show ViewDefinitionsToolArguments
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ViewDefinitionsToolArguments -> ShowS
showsPrec :: Int -> ViewDefinitionsToolArguments -> ShowS
$cshow :: ViewDefinitionsToolArguments -> [Char]
show :: ViewDefinitionsToolArguments -> [Char]
$cshowList :: [ViewDefinitionsToolArguments] -> ShowS
showList :: [ViewDefinitionsToolArguments] -> ShowS
Show)

instance HasInputSchema ViewDefinitionsToolArguments where
  toInputSchema :: Proxy ViewDefinitionsToolArguments -> Value
toInputSchema Proxy ViewDefinitionsToolArguments
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Proxy ProjectContext -> Value
forall {k} (arg :: k). HasInputSchema arg => Proxy arg -> Value
toInputSchema (Proxy ProjectContext
forall {k} (t :: k). Proxy t
Proxy :: Proxy ProjectContext),
              Key
"names"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"array" :: Text),
                    Key
"items"
                      Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                        [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                          Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The names of the definitions to view, e.g. `mynamespace.foo` or `lib.unison_base_1_0_0.data.List`." :: Text)
                        ],
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The names of the definitions to view." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"projectContext", Text
"names" :: Text]
      ]

instance FromJSON ViewDefinitionsToolArguments where
  parseJSON :: Value -> Parser ViewDefinitionsToolArguments
parseJSON = [Char]
-> (Object -> Parser ViewDefinitionsToolArguments)
-> Value
-> Parser ViewDefinitionsToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"ViewDefinitionsToolArguments" ((Object -> Parser ViewDefinitionsToolArguments)
 -> Value -> Parser ViewDefinitionsToolArguments)
-> (Object -> Parser ViewDefinitionsToolArguments)
-> Value
-> Parser ViewDefinitionsToolArguments
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    ProjectContext
projectContext <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    [Name]
names <- (Text -> Name) -> [Text] -> [Name]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap HasCallStack => Text -> Name
Text -> Name
Name.unsafeParseText ([Text] -> [Name]) -> Parser [Text] -> Parser [Name]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser [Text]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"names"
    ViewDefinitionsToolArguments -> Parser ViewDefinitionsToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ViewDefinitionsToolArguments
 -> Parser ViewDefinitionsToolArguments)
-> ViewDefinitionsToolArguments
-> Parser ViewDefinitionsToolArguments
forall a b. (a -> b) -> a -> b
$ ViewDefinitionsToolArguments {ProjectContext
$sel:projectContext:ViewDefinitionsToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, [Name]
$sel:names:ViewDefinitionsToolArguments :: [Name]
names :: [Name]
names}

data ListLibraryDefinitionsToolArguments = ListLibraryDefinitionsToolArguments
  { ListLibraryDefinitionsToolArguments -> ProjectContext
projectContext :: ProjectContext,
    ListLibraryDefinitionsToolArguments -> Text
libName :: Text
  }
  deriving (ListLibraryDefinitionsToolArguments
-> ListLibraryDefinitionsToolArguments -> Bool
(ListLibraryDefinitionsToolArguments
 -> ListLibraryDefinitionsToolArguments -> Bool)
-> (ListLibraryDefinitionsToolArguments
    -> ListLibraryDefinitionsToolArguments -> Bool)
-> Eq ListLibraryDefinitionsToolArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListLibraryDefinitionsToolArguments
-> ListLibraryDefinitionsToolArguments -> Bool
== :: ListLibraryDefinitionsToolArguments
-> ListLibraryDefinitionsToolArguments -> Bool
$c/= :: ListLibraryDefinitionsToolArguments
-> ListLibraryDefinitionsToolArguments -> Bool
/= :: ListLibraryDefinitionsToolArguments
-> ListLibraryDefinitionsToolArguments -> Bool
Eq, Int -> ListLibraryDefinitionsToolArguments -> ShowS
[ListLibraryDefinitionsToolArguments] -> ShowS
ListLibraryDefinitionsToolArguments -> [Char]
(Int -> ListLibraryDefinitionsToolArguments -> ShowS)
-> (ListLibraryDefinitionsToolArguments -> [Char])
-> ([ListLibraryDefinitionsToolArguments] -> ShowS)
-> Show ListLibraryDefinitionsToolArguments
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ListLibraryDefinitionsToolArguments -> ShowS
showsPrec :: Int -> ListLibraryDefinitionsToolArguments -> ShowS
$cshow :: ListLibraryDefinitionsToolArguments -> [Char]
show :: ListLibraryDefinitionsToolArguments -> [Char]
$cshowList :: [ListLibraryDefinitionsToolArguments] -> ShowS
showList :: [ListLibraryDefinitionsToolArguments] -> ShowS
Show)

instance HasInputSchema ListLibraryDefinitionsToolArguments where
  toInputSchema :: Proxy ListLibraryDefinitionsToolArguments -> Value
toInputSchema Proxy ListLibraryDefinitionsToolArguments
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Proxy ProjectContext -> Value
forall {k} (arg :: k). HasInputSchema arg => Proxy arg -> Value
toInputSchema (Proxy ProjectContext
forall {k} (t :: k). Proxy t
Proxy :: Proxy ProjectContext),
              Key
"libName"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The name of the library to list definitions for, e.g. `base` or `json`." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"projectContext", Text
"libName" :: Text]
      ]

instance FromJSON ListLibraryDefinitionsToolArguments where
  parseJSON :: Value -> Parser ListLibraryDefinitionsToolArguments
parseJSON = [Char]
-> (Object -> Parser ListLibraryDefinitionsToolArguments)
-> Value
-> Parser ListLibraryDefinitionsToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"ListLibraryDefinitionsToolArguments" ((Object -> Parser ListLibraryDefinitionsToolArguments)
 -> Value -> Parser ListLibraryDefinitionsToolArguments)
-> (Object -> Parser ListLibraryDefinitionsToolArguments)
-> Value
-> Parser ListLibraryDefinitionsToolArguments
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    ProjectContext
projectContext <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    Text
libName <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"libName"
    ListLibraryDefinitionsToolArguments
-> Parser ListLibraryDefinitionsToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ListLibraryDefinitionsToolArguments
 -> Parser ListLibraryDefinitionsToolArguments)
-> ListLibraryDefinitionsToolArguments
-> Parser ListLibraryDefinitionsToolArguments
forall a b. (a -> b) -> a -> b
$ ListLibraryDefinitionsToolArguments {ProjectContext
$sel:projectContext:ListLibraryDefinitionsToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, Text
$sel:libName:ListLibraryDefinitionsToolArguments :: Text
libName :: Text
libName}

data ShareProjectReadmeToolArguments = ShareProjectReadmeToolArguments
  { ShareProjectReadmeToolArguments -> Text
projectName :: Text,
    ShareProjectReadmeToolArguments -> Text
projectOwnerHandle :: Text
  }
  deriving (ShareProjectReadmeToolArguments
-> ShareProjectReadmeToolArguments -> Bool
(ShareProjectReadmeToolArguments
 -> ShareProjectReadmeToolArguments -> Bool)
-> (ShareProjectReadmeToolArguments
    -> ShareProjectReadmeToolArguments -> Bool)
-> Eq ShareProjectReadmeToolArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShareProjectReadmeToolArguments
-> ShareProjectReadmeToolArguments -> Bool
== :: ShareProjectReadmeToolArguments
-> ShareProjectReadmeToolArguments -> Bool
$c/= :: ShareProjectReadmeToolArguments
-> ShareProjectReadmeToolArguments -> Bool
/= :: ShareProjectReadmeToolArguments
-> ShareProjectReadmeToolArguments -> Bool
Eq, Int -> ShareProjectReadmeToolArguments -> ShowS
[ShareProjectReadmeToolArguments] -> ShowS
ShareProjectReadmeToolArguments -> [Char]
(Int -> ShareProjectReadmeToolArguments -> ShowS)
-> (ShareProjectReadmeToolArguments -> [Char])
-> ([ShareProjectReadmeToolArguments] -> ShowS)
-> Show ShareProjectReadmeToolArguments
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShareProjectReadmeToolArguments -> ShowS
showsPrec :: Int -> ShareProjectReadmeToolArguments -> ShowS
$cshow :: ShareProjectReadmeToolArguments -> [Char]
show :: ShareProjectReadmeToolArguments -> [Char]
$cshowList :: [ShareProjectReadmeToolArguments] -> ShowS
showList :: [ShareProjectReadmeToolArguments] -> ShowS
Show)

instance HasInputSchema ShareProjectReadmeToolArguments where
  toInputSchema :: Proxy ShareProjectReadmeToolArguments -> Value
toInputSchema Proxy ShareProjectReadmeToolArguments
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
            [ Key
"projectName"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The name of the project to fetch the README for. E.g. in a project reference like `@owner/project-name` this would be `project-name`" :: Text)
                  ],
              Key
"projectOwnerHandle"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The handle of the project owner, e.g. in a project reference like `@owner/project-name` this would be `owner`" :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"projectName", Text
"projectOwnerHandle" :: Text]
      ]

instance FromJSON ShareProjectReadmeToolArguments where
  parseJSON :: Value -> Parser ShareProjectReadmeToolArguments
parseJSON = [Char]
-> (Object -> Parser ShareProjectReadmeToolArguments)
-> Value
-> Parser ShareProjectReadmeToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"ShareProjectReadmeToolArguments" ((Object -> Parser ShareProjectReadmeToolArguments)
 -> Value -> Parser ShareProjectReadmeToolArguments)
-> (Object -> Parser ShareProjectReadmeToolArguments)
-> Value
-> Parser ShareProjectReadmeToolArguments
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    Text
projectName <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectName"
    Text
projectOwnerHandle <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectOwnerHandle"
    ShareProjectReadmeToolArguments
-> Parser ShareProjectReadmeToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ShareProjectReadmeToolArguments
 -> Parser ShareProjectReadmeToolArguments)
-> ShareProjectReadmeToolArguments
-> Parser ShareProjectReadmeToolArguments
forall a b. (a -> b) -> a -> b
$ ShareProjectReadmeToolArguments {Text
$sel:projectName:ShareProjectReadmeToolArguments :: Text
projectName :: Text
projectName, Text
$sel:projectOwnerHandle:ShareProjectReadmeToolArguments :: Text
projectOwnerHandle :: Text
projectOwnerHandle}

data TypecheckCodeToolArguments = TypecheckCodeToolArguments
  { TypecheckCodeToolArguments -> ProjectContext
projectContext :: ProjectContext,
    TypecheckCodeToolArguments -> Either [Char] Text
code :: Either FilePath Text
  }
  deriving (TypecheckCodeToolArguments -> TypecheckCodeToolArguments -> Bool
(TypecheckCodeToolArguments -> TypecheckCodeToolArguments -> Bool)
-> (TypecheckCodeToolArguments
    -> TypecheckCodeToolArguments -> Bool)
-> Eq TypecheckCodeToolArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypecheckCodeToolArguments -> TypecheckCodeToolArguments -> Bool
== :: TypecheckCodeToolArguments -> TypecheckCodeToolArguments -> Bool
$c/= :: TypecheckCodeToolArguments -> TypecheckCodeToolArguments -> Bool
/= :: TypecheckCodeToolArguments -> TypecheckCodeToolArguments -> Bool
Eq, Int -> TypecheckCodeToolArguments -> ShowS
[TypecheckCodeToolArguments] -> ShowS
TypecheckCodeToolArguments -> [Char]
(Int -> TypecheckCodeToolArguments -> ShowS)
-> (TypecheckCodeToolArguments -> [Char])
-> ([TypecheckCodeToolArguments] -> ShowS)
-> Show TypecheckCodeToolArguments
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TypecheckCodeToolArguments -> ShowS
showsPrec :: Int -> TypecheckCodeToolArguments -> ShowS
$cshow :: TypecheckCodeToolArguments -> [Char]
show :: TypecheckCodeToolArguments -> [Char]
$cshowList :: [TypecheckCodeToolArguments] -> ShowS
showList :: [TypecheckCodeToolArguments] -> ShowS
Show)

instance HasInputSchema TypecheckCodeToolArguments where
  toInputSchema :: Proxy TypecheckCodeToolArguments -> Value
toInputSchema Proxy TypecheckCodeToolArguments
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Proxy ProjectContext -> Value
forall {k} (arg :: k). HasInputSchema arg => Proxy arg -> Value
toInputSchema (Proxy ProjectContext
forall {k} (t :: k). Proxy t
Proxy :: Proxy ProjectContext),
              Key
"code"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The source code to typecheck. If a string, it is the source code itself. If a file path, it is the path to a file containing the source code." :: Text),
                    Key
"oneOf"
                      Key -> [Value] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [ [Pair] -> Value
object
                             [ Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The file path to the source code." :: Text),
                               Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
                               Key
"properties"
                                 Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                                   [ Key
"filePath"
                                       Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                                         [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                                           Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"An absolute file path to the source code." :: Text)
                                         ]
                                   ],
                               Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"filePath" :: Text],
                               Key
"additionalProperties" Key -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Bool
False
                             ],
                           [Pair] -> Value
object
                             [ Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The source code to typecheck." :: Text),
                               Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
                               Key
"properties"
                                 Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                                   [ Key
"text"
                                       Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                                         [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                                           Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The source code to typecheck." :: Text)
                                         ]
                                   ],
                               Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"text" :: Text],
                               Key
"additionalProperties" Key -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Bool
False
                             ]
                         ]
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"projectContext", Text
"code" :: Text]
      ]

instance FromJSON TypecheckCodeToolArguments where
  parseJSON :: Value -> Parser TypecheckCodeToolArguments
parseJSON = [Char]
-> (Object -> Parser TypecheckCodeToolArguments)
-> Value
-> Parser TypecheckCodeToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"TypecheckCodeToolArguments" ((Object -> Parser TypecheckCodeToolArguments)
 -> Value -> Parser TypecheckCodeToolArguments)
-> (Object -> Parser TypecheckCodeToolArguments)
-> Value
-> Parser TypecheckCodeToolArguments
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    ProjectContext
projectContext <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    Object
source <- Object
o Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"code"
    Object
source Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"filePath" Parser (Maybe [Char])
-> (Maybe [Char] -> Parser TypecheckCodeToolArguments)
-> Parser TypecheckCodeToolArguments
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      Just [Char]
filePath -> TypecheckCodeToolArguments -> Parser TypecheckCodeToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypecheckCodeToolArguments -> Parser TypecheckCodeToolArguments)
-> TypecheckCodeToolArguments -> Parser TypecheckCodeToolArguments
forall a b. (a -> b) -> a -> b
$ TypecheckCodeToolArguments {ProjectContext
$sel:projectContext:TypecheckCodeToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, $sel:code:TypecheckCodeToolArguments :: Either [Char] Text
code = [Char] -> Either [Char] Text
forall a b. a -> Either a b
Left [Char]
filePath}
      Maybe [Char]
Nothing -> do
        Text
text <- Object
source Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"text"
        TypecheckCodeToolArguments -> Parser TypecheckCodeToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TypecheckCodeToolArguments -> Parser TypecheckCodeToolArguments)
-> TypecheckCodeToolArguments -> Parser TypecheckCodeToolArguments
forall a b. (a -> b) -> a -> b
$ TypecheckCodeToolArguments {ProjectContext
$sel:projectContext:TypecheckCodeToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, $sel:code:TypecheckCodeToolArguments :: Either [Char] Text
code = Text -> Either [Char] Text
forall a b. b -> Either a b
Right Text
text}

data DocsToolArguments = DocsToolArguments
  { DocsToolArguments -> ProjectContext
projectContext :: ProjectContext,
    DocsToolArguments -> Name
name :: Name
  }
  deriving (DocsToolArguments -> DocsToolArguments -> Bool
(DocsToolArguments -> DocsToolArguments -> Bool)
-> (DocsToolArguments -> DocsToolArguments -> Bool)
-> Eq DocsToolArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DocsToolArguments -> DocsToolArguments -> Bool
== :: DocsToolArguments -> DocsToolArguments -> Bool
$c/= :: DocsToolArguments -> DocsToolArguments -> Bool
/= :: DocsToolArguments -> DocsToolArguments -> Bool
Eq, Int -> DocsToolArguments -> ShowS
[DocsToolArguments] -> ShowS
DocsToolArguments -> [Char]
(Int -> DocsToolArguments -> ShowS)
-> (DocsToolArguments -> [Char])
-> ([DocsToolArguments] -> ShowS)
-> Show DocsToolArguments
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DocsToolArguments -> ShowS
showsPrec :: Int -> DocsToolArguments -> ShowS
$cshow :: DocsToolArguments -> [Char]
show :: DocsToolArguments -> [Char]
$cshowList :: [DocsToolArguments] -> ShowS
showList :: [DocsToolArguments] -> ShowS
Show)

instance HasInputSchema DocsToolArguments where
  toInputSchema :: Proxy DocsToolArguments -> Value
toInputSchema Proxy DocsToolArguments
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
            [ Key
"name"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The definition name to fetch documentation for. E.g. `README` or `data.Map.fromList`" :: Text)
                  ],
              Key
"projectContext" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Proxy ProjectContext -> Value
forall {k} (arg :: k). HasInputSchema arg => Proxy arg -> Value
toInputSchema (Proxy ProjectContext
forall {k} (t :: k). Proxy t
Proxy :: Proxy ProjectContext)
            ],
        Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"name", Text
"projectContext" :: Text]
      ]

instance FromJSON DocsToolArguments where
  parseJSON :: Value -> Parser DocsToolArguments
parseJSON = [Char]
-> (Object -> Parser DocsToolArguments)
-> Value
-> Parser DocsToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"DocsToolArguments" ((Object -> Parser DocsToolArguments)
 -> Value -> Parser DocsToolArguments)
-> (Object -> Parser DocsToolArguments)
-> Value
-> Parser DocsToolArguments
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    ProjectContext
projectContext <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    Name
name <- HasCallStack => Text -> Name
Text -> Name
Name.unsafeParseText (Text -> Name) -> Parser Text -> Parser Name
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
    DocsToolArguments -> Parser DocsToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (DocsToolArguments -> Parser DocsToolArguments)
-> DocsToolArguments -> Parser DocsToolArguments
forall a b. (a -> b) -> a -> b
$ DocsToolArguments {ProjectContext
$sel:projectContext:DocsToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, Name
$sel:name:DocsToolArguments :: Name
name :: Name
name}

data ProjectCodeToolArguments = ProjectCodeToolArguments
  { ProjectCodeToolArguments -> ProjectContext
projectContext :: ProjectContext
  }

instance FromJSON ProjectCodeToolArguments where
  parseJSON :: Value -> Parser ProjectCodeToolArguments
parseJSON = [Char]
-> (Object -> Parser ProjectCodeToolArguments)
-> Value
-> Parser ProjectCodeToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"ProjectCodeToolArguments" ((Object -> Parser ProjectCodeToolArguments)
 -> Value -> Parser ProjectCodeToolArguments)
-> (Object -> Parser ProjectCodeToolArguments)
-> Value
-> Parser ProjectCodeToolArguments
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    ProjectContext
projectContext <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    ProjectCodeToolArguments -> Parser ProjectCodeToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ProjectCodeToolArguments -> Parser ProjectCodeToolArguments)
-> ProjectCodeToolArguments -> Parser ProjectCodeToolArguments
forall a b. (a -> b) -> a -> b
$ ProjectCodeToolArguments {ProjectContext
$sel:projectContext:ProjectCodeToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext}

data ProjectContext = ProjectContext
  { ProjectContext -> ProjectName
projectName :: ProjectName,
    ProjectContext -> ProjectBranchName
branchName :: ProjectBranchName
  }
  deriving (ProjectContext -> ProjectContext -> Bool
(ProjectContext -> ProjectContext -> Bool)
-> (ProjectContext -> ProjectContext -> Bool) -> Eq ProjectContext
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectContext -> ProjectContext -> Bool
== :: ProjectContext -> ProjectContext -> Bool
$c/= :: ProjectContext -> ProjectContext -> Bool
/= :: ProjectContext -> ProjectContext -> Bool
Eq, Int -> ProjectContext -> ShowS
[ProjectContext] -> ShowS
ProjectContext -> [Char]
(Int -> ProjectContext -> ShowS)
-> (ProjectContext -> [Char])
-> ([ProjectContext] -> ShowS)
-> Show ProjectContext
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectContext -> ShowS
showsPrec :: Int -> ProjectContext -> ShowS
$cshow :: ProjectContext -> [Char]
show :: ProjectContext -> [Char]
$cshowList :: [ProjectContext] -> ShowS
showList :: [ProjectContext] -> ShowS
Show)

instance HasInputSchema ProjectContext where
  toInputSchema :: Proxy ProjectContext -> Value
toInputSchema Proxy ProjectContext
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
            [ Key
"projectName"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The name of the project to work within, e.g. `@unison/base` or `@ceedubs/json`" :: Text)
                  ],
              Key
"branchName"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The branch of the project to work within, e.g. `main` or `develop`" :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"projectName", Text
"branchName" :: Text]
      ]

instance FromJSON ProjectContext where
  parseJSON :: Value -> Parser ProjectContext
parseJSON = [Char]
-> (Object -> Parser ProjectContext)
-> Value
-> Parser ProjectContext
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"ProjectContext" ((Object -> Parser ProjectContext)
 -> Value -> Parser ProjectContext)
-> (Object -> Parser ProjectContext)
-> Value
-> Parser ProjectContext
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    ProjectName
projectName <- Text -> ProjectName
UnsafeProjectName (Text -> ProjectName) -> Parser Text -> Parser ProjectName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectName"
    ProjectBranchName
branchName <- Text -> ProjectBranchName
UnsafeProjectBranchName (Text -> ProjectBranchName)
-> Parser Text -> Parser ProjectBranchName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"branchName"
    ProjectContext -> Parser ProjectContext
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ProjectContext -> Parser ProjectContext)
-> ProjectContext -> Parser ProjectContext
forall a b. (a -> b) -> a -> b
$ ProjectContext {ProjectName
$sel:projectName:ProjectContext :: ProjectName
projectName :: ProjectName
projectName, ProjectBranchName
$sel:branchName:ProjectContext :: ProjectBranchName
branchName :: ProjectBranchName
branchName}

instance ToJSON ProjectContext where
  toJSON :: ProjectContext -> Value
toJSON (ProjectContext (UnsafeProjectName Text
projectName) (UnsafeProjectBranchName Text
branchName)) =
    [Pair] -> Value
object
      [ Key
"projectName" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
projectName,
        Key
"branchName" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Text
branchName
      ]

data LibInstallToolArguments = LibInstallToolArguments
  { LibInstallToolArguments -> ProjectContext
projectContext :: ProjectContext,
    LibInstallToolArguments -> Text
libProjectName :: Text,
    LibInstallToolArguments -> Maybe Text
libBranchName :: Maybe Text
  }

instance FromJSON LibInstallToolArguments where
  parseJSON :: Value -> Parser LibInstallToolArguments
parseJSON = [Char]
-> (Object -> Parser LibInstallToolArguments)
-> Value
-> Parser LibInstallToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"LibInstallToolArguments" ((Object -> Parser LibInstallToolArguments)
 -> Value -> Parser LibInstallToolArguments)
-> (Object -> Parser LibInstallToolArguments)
-> Value
-> Parser LibInstallToolArguments
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    ProjectContext
projectContext <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    Text
libProjectName <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"libProjectName"
    Maybe Text
libBranchName <- Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"libBranchName"
    LibInstallToolArguments -> Parser LibInstallToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (LibInstallToolArguments -> Parser LibInstallToolArguments)
-> LibInstallToolArguments -> Parser LibInstallToolArguments
forall a b. (a -> b) -> a -> b
$
      LibInstallToolArguments
        { ProjectContext
$sel:projectContext:LibInstallToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext,
          Text
$sel:libProjectName:LibInstallToolArguments :: Text
libProjectName :: Text
libProjectName,
          Maybe Text
$sel:libBranchName:LibInstallToolArguments :: Maybe Text
libBranchName :: Maybe Text
libBranchName
        }

instance HasInputSchema LibInstallToolArguments where
  toInputSchema :: Proxy LibInstallToolArguments -> Value
toInputSchema Proxy LibInstallToolArguments
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= Proxy ProjectContext -> Value
forall {k} (arg :: k). HasInputSchema arg => Proxy arg -> Value
toInputSchema (Proxy ProjectContext
forall {k} (t :: k). Proxy t
Proxy :: Proxy ProjectContext),
              Key
"libProjectName"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                    Key
"The user-qualified name of the library project to install, e.g. `@unison/base` or `@ceedubs/json`" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The name of the library project to install" :: Text)
                  ],
              Key
"libBranchName"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"type" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"string" :: Text, Text
"null"],
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The optional branch of the library project to install, E.g. `main`. If null, the latest release will be used." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"projectContext", Text
"libProjectName" :: Text]
      ]

data ShareProjectSearchToolArguments = ShareProjectSearchToolArguments
  { ShareProjectSearchToolArguments -> Text
query :: Text
  }
  deriving (ShareProjectSearchToolArguments
-> ShareProjectSearchToolArguments -> Bool
(ShareProjectSearchToolArguments
 -> ShareProjectSearchToolArguments -> Bool)
-> (ShareProjectSearchToolArguments
    -> ShareProjectSearchToolArguments -> Bool)
-> Eq ShareProjectSearchToolArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShareProjectSearchToolArguments
-> ShareProjectSearchToolArguments -> Bool
== :: ShareProjectSearchToolArguments
-> ShareProjectSearchToolArguments -> Bool
$c/= :: ShareProjectSearchToolArguments
-> ShareProjectSearchToolArguments -> Bool
/= :: ShareProjectSearchToolArguments
-> ShareProjectSearchToolArguments -> Bool
Eq, Int -> ShareProjectSearchToolArguments -> ShowS
[ShareProjectSearchToolArguments] -> ShowS
ShareProjectSearchToolArguments -> [Char]
(Int -> ShareProjectSearchToolArguments -> ShowS)
-> (ShareProjectSearchToolArguments -> [Char])
-> ([ShareProjectSearchToolArguments] -> ShowS)
-> Show ShareProjectSearchToolArguments
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShareProjectSearchToolArguments -> ShowS
showsPrec :: Int -> ShareProjectSearchToolArguments -> ShowS
$cshow :: ShareProjectSearchToolArguments -> [Char]
show :: ShareProjectSearchToolArguments -> [Char]
$cshowList :: [ShareProjectSearchToolArguments] -> ShowS
showList :: [ShareProjectSearchToolArguments] -> ShowS
Show)

instance HasInputSchema ShareProjectSearchToolArguments where
  toInputSchema :: Proxy ShareProjectSearchToolArguments -> Value
toInputSchema Proxy ShareProjectSearchToolArguments
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
            [ Key
"query"
                Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"The search query to use. E.g. \"http client\". By default, each search word is ANDed together, but you can use OR to search for multiple terms. E.g. \"http OR client\" will return results that match either term. You can also exclude results using \"-\", e.g. \"-http\" will exclude results that match the term \"http\". Wrap a term in quotes to search for an exact phrase, e.g. \"\"http client\"\" will search for the exact phrase \"http client\"." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= [Text
"query" :: Text]
      ]

instance FromJSON ShareProjectSearchToolArguments where
  parseJSON :: Value -> Parser ShareProjectSearchToolArguments
parseJSON = [Char]
-> (Object -> Parser ShareProjectSearchToolArguments)
-> Value
-> Parser ShareProjectSearchToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"ShareProjectSearchToolArguments" ((Object -> Parser ShareProjectSearchToolArguments)
 -> Value -> Parser ShareProjectSearchToolArguments)
-> (Object -> Parser ShareProjectSearchToolArguments)
-> Value
-> Parser ShareProjectSearchToolArguments
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    Text
query <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
    ShareProjectSearchToolArguments
-> Parser ShareProjectSearchToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ShareProjectSearchToolArguments
 -> Parser ShareProjectSearchToolArguments)
-> ShareProjectSearchToolArguments
-> Parser ShareProjectSearchToolArguments
forall a b. (a -> b) -> a -> b
$ ShareProjectSearchToolArguments {Text
$sel:query:ShareProjectSearchToolArguments :: Text
query :: Text
query}

nameKindMapping :: Map Text ToolKind
nameKindMapping :: Map Text ToolKind
nameKindMapping =
  (Map ToolKind Text -> [(ToolKind, Text)]
forall k a. Map k a -> [(k, a)]
Map.toList Map ToolKind Text
kindNameMapping)
    [(ToolKind, Text)]
-> ([(ToolKind, Text)] -> [(Text, ToolKind)]) -> [(Text, ToolKind)]
forall a b. a -> (a -> b) -> b
& ((ToolKind, Text) -> (Text, ToolKind))
-> [(ToolKind, Text)] -> [(Text, ToolKind)]
forall a b. (a -> b) -> [a] -> [b]
map (\(ToolKind
k, Text
v) -> (Text
v, ToolKind
k))
    [(Text, ToolKind)]
-> ([(Text, ToolKind)] -> Map Text ToolKind) -> Map Text ToolKind
forall a b. a -> (a -> b) -> b
& [(Text, ToolKind)] -> Map Text ToolKind
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList

toToolName :: ToolKind -> Text.Text
toToolName :: ToolKind -> Text
toToolName ToolKind
kind =
  (ToolKind -> Map ToolKind Text -> Maybe Text
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup ToolKind
kind Map ToolKind Text
kindNameMapping)
    Maybe Text -> (Maybe Text -> Text) -> Text
forall a b. a -> (a -> b) -> b
& Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> Text
forall a. HasCallStack => [Char] -> a
error ([Char] -> Text) -> [Char] -> Text
forall a b. (a -> b) -> a -> b
$ [Char]
"Unknown tool kind: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ToolKind -> [Char]
forall a. Show a => a -> [Char]
show ToolKind
kind)

fromToolName :: Text.Text -> Maybe ToolKind
fromToolName :: Text -> Maybe ToolKind
fromToolName Text
name = Text -> Map Text ToolKind -> Maybe ToolKind
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Text
name Map Text ToolKind
nameKindMapping