{-# LANGUAGE NoFieldSelectors #-}

module Unison.MCP.Types
  ( MCP (..),
    Env (..),
    runMCP,
    ToolKind (..),
    ProjectCodeToolArguments (..),
    LibInstallToolArguments (..),
    ShareProjectSearchToolArguments (..),
    TypecheckCodeToolArguments (..),
    ShareProjectReadmeToolArguments (..),
    ListLibraryDefinitionsToolArguments (..),
    ViewDefinitionsToolArguments (..),
    UpdateDefinitionsToolArguments (..),
    DiffUpdateToolArguments (..),
    SearchDefinitionsToolArguments (..),
    SearchByTypeToolArguments (..),
    DocsToolArguments (..),
    RunToolArguments (..),
    ProjectContext (..),
    ProjectContextArgument (..),
    ProjectNameArgument (..),
    ProjectDefinitionNameArgument (..),
    TestToolArguments (..),
    DeleteDefinitionsToolArguments (..),
    RenameDefinitionToolArguments (..),
    MoveDefinitionToolArguments (..),
    MoveToToolArguments (..),
    DeleteNamespaceToolArguments (..),
    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.Path qualified as Path
import Unison.Core.Project (ProjectBranchName (UnsafeProjectBranchName), ProjectName (UnsafeProjectName))
import Unison.MCP.Wrapper (HasInputSchema (..))
import Unison.Name (Name)
import Unison.NameSegment (NameSegment)
import Unison.Parser.Ann (Ann)
import Unison.Prelude
import Unison.Runtime (Runtime)
import Unison.Symbol (Symbol)
import Unison.Syntax.Name qualified as Name
import Unison.Syntax.NameSegment qualified as NameSegment

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
  | RunTool
  | ListProjectDefinitionsTool
  | ListProjectLibrariesTool
  | ListLibraryDefinitionsTool
  | ViewDefinitionsTool
  | UpdateDefinitionsTool
  | SearchDefinitionsTool
  | SearchByTypeTool
  | ListLocalProjectsTool
  | ListProjectBranchesTool
  | GetCurrentProjectContextTool
  | DependenciesTool
  | DependentsTool
  | TestsTool
  | DeleteDefinitionsTool
  | RenameDefinitionTool
  | MoveDefinitionTool
  | MoveToTool
  | DeleteNamespaceTool
  | DiffUpdateTool
  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
RunTool, Text
"run"),
      (ToolKind
ListProjectDefinitionsTool, Text
"list-project-definitions"),
      (ToolKind
ListProjectLibrariesTool, Text
"list-project-libraries"),
      (ToolKind
ListLibraryDefinitionsTool, Text
"list-library-definitions"),
      (ToolKind
ViewDefinitionsTool, Text
"view-definitions"),
      (ToolKind
UpdateDefinitionsTool, Text
"update-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"),
      (ToolKind
TestsTool, Text
"run-tests"),
      (ToolKind
DeleteDefinitionsTool, Text
"delete-definitions"),
      (ToolKind
RenameDefinitionTool, Text
"rename-definition"),
      (ToolKind
MoveDefinitionTool, Text
"move-definition"),
      (ToolKind
MoveToTool, Text
"move-to"),
      (ToolKind
DeleteNamespaceTool, Text
"delete-namespace"),
      (ToolKind
DiffUpdateTool, Text
"diff-update")
    ]

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

instance HasInputSchema UpdateDefinitionsToolArguments where
  toInputSchema :: Proxy UpdateDefinitionsToolArguments -> Value
toInputSchema Proxy UpdateDefinitionsToolArguments
_ =
    [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 update definitions to. Either the `sourceCode` key or the `filePath`, but not both." :: 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
"sourceCode"
                            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 update definitions to." :: Text)
                              ],
                          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
"The absolute file path to the source code." :: 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
"minProperties" Key -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Int
1 :: Int),
                    Key
"maxProperties" Key -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Int
1 :: Int)
                  ]
            ],
        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 UpdateDefinitionsToolArguments where
  parseJSON :: Value -> Parser UpdateDefinitionsToolArguments
parseJSON = [Char]
-> (Object -> Parser UpdateDefinitionsToolArguments)
-> Value
-> Parser UpdateDefinitionsToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"UpdateDefinitionsToolArguments" ((Object -> Parser UpdateDefinitionsToolArguments)
 -> Value -> Parser UpdateDefinitionsToolArguments)
-> (Object -> Parser UpdateDefinitionsToolArguments)
-> Value
-> Parser UpdateDefinitionsToolArguments
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"
    Maybe [Char]
mFilePath <- Object
source Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"filePath"
    Maybe Text
mSourceCode <- Object
source Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"sourceCode"
    Maybe Text
mText <- Object
source Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"text"
    let providedCount :: Int
providedCount =
          [Bool] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length
            ((Bool -> Bool) -> [Bool] -> [Bool]
forall a. (a -> Bool) -> [a] -> [a]
filter Bool -> Bool
forall a. a -> a
id [Maybe [Char] -> Bool
forall a. Maybe a -> Bool
isJust Maybe [Char]
mFilePath, Maybe Text -> Bool
forall a. Maybe a -> Bool
isJust Maybe Text
mSourceCode, Maybe Text -> Bool
forall a. Maybe a -> Bool
isJust Maybe Text
mText])
    Bool -> Parser () -> Parser ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
providedCount Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0) (Parser () -> Parser ()) -> Parser () -> Parser ()
forall a b. (a -> b) -> a -> b
$
      [Char] -> Parser ()
forall a. [Char] -> Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"Expected one of: code.filePath, code.sourceCode"
    Bool -> Parser () -> Parser ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
providedCount Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1) (Parser () -> Parser ()) -> Parser () -> Parser ()
forall a b. (a -> b) -> a -> b
$
      [Char] -> Parser ()
forall a. [Char] -> Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"Expected exactly one of: code.filePath, code.sourceCode"
    Either [Char] Text
code <- case (Maybe [Char]
mFilePath, Maybe Text
mSourceCode, Maybe Text
mText) of
      (Just [Char]
filePath, Maybe Text
_, Maybe Text
_) -> Either [Char] Text -> Parser (Either [Char] Text)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Char] -> Either [Char] Text
forall a b. a -> Either a b
Left [Char]
filePath)
      (Maybe [Char]
_, Just Text
sourceCode, Maybe Text
_) -> Either [Char] Text -> Parser (Either [Char] Text)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> Either [Char] Text
forall a b. b -> Either a b
Right Text
sourceCode)
      (Maybe [Char]
_, Maybe Text
_, Just Text
text) -> Either [Char] Text -> Parser (Either [Char] Text)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> Either [Char] Text
forall a b. b -> Either a b
Right Text
text)
      (Maybe [Char], Maybe Text, Maybe Text)
_ -> [Char] -> Parser (Either [Char] Text)
forall a. [Char] -> Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"Expected one of: code.filePath, code.sourceCode"
    UpdateDefinitionsToolArguments
-> Parser UpdateDefinitionsToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (UpdateDefinitionsToolArguments
 -> Parser UpdateDefinitionsToolArguments)
-> UpdateDefinitionsToolArguments
-> Parser UpdateDefinitionsToolArguments
forall a b. (a -> b) -> a -> b
$ UpdateDefinitionsToolArguments {ProjectContext
$sel:projectContext:UpdateDefinitionsToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, Either [Char] Text
$sel:code:UpdateDefinitionsToolArguments :: Either [Char] Text
code :: Either [Char] Text
code}

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

instance HasInputSchema DiffUpdateToolArguments where
  toInputSchema :: Proxy DiffUpdateToolArguments -> Value
toInputSchema Proxy DiffUpdateToolArguments
_ =
    [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 diff against the current codebase. 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 use." :: 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." :: 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 DiffUpdateToolArguments where
  parseJSON :: Value -> Parser DiffUpdateToolArguments
parseJSON = [Char]
-> (Object -> Parser DiffUpdateToolArguments)
-> Value
-> Parser DiffUpdateToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"DiffUpdateToolArguments" ((Object -> Parser DiffUpdateToolArguments)
 -> Value -> Parser DiffUpdateToolArguments)
-> (Object -> Parser DiffUpdateToolArguments)
-> Value
-> Parser DiffUpdateToolArguments
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"
    Either [Char] Text
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 (Either [Char] Text))
-> Parser (Either [Char] Text)
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 -> Either [Char] Text -> Parser (Either [Char] Text)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either [Char] Text -> Parser (Either [Char] Text))
-> Either [Char] Text -> Parser (Either [Char] Text)
forall a b. (a -> b) -> a -> b
$ [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"
          Either [Char] Text -> Parser (Either [Char] Text)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Either [Char] Text -> Parser (Either [Char] Text))
-> Either [Char] Text -> Parser (Either [Char] Text)
forall a b. (a -> b) -> a -> b
$ Text -> Either [Char] Text
forall a b. b -> Either a b
Right Text
text
    DiffUpdateToolArguments -> Parser DiffUpdateToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (DiffUpdateToolArguments -> Parser DiffUpdateToolArguments)
-> DiffUpdateToolArguments -> Parser DiffUpdateToolArguments
forall a b. (a -> b) -> a -> b
$ DiffUpdateToolArguments {ProjectContext
$sel:projectContext:DiffUpdateToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, Either [Char] Text
$sel:code:DiffUpdateToolArguments :: Either [Char] Text
code :: Either [Char] Text
code}

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. Either the `sourceCode` key or the `filePath`, but not both." :: 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
"sourceCode"
                            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
"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
"The absolute file path to the source code to typecheck." :: 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
"minProperties" Key -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Int
1 :: Int),
                    Key
"maxProperties" Key -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Int
1 :: Int)
                  ]
            ],
        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
"sourceCode"
        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 RunToolArguments = RunToolArguments
  { RunToolArguments -> ProjectContext
projectContext :: ProjectContext,
    RunToolArguments -> Name
mainFunctionName :: Name,
    RunToolArguments -> [Text]
args :: [Text]
  }
  deriving (RunToolArguments -> RunToolArguments -> Bool
(RunToolArguments -> RunToolArguments -> Bool)
-> (RunToolArguments -> RunToolArguments -> Bool)
-> Eq RunToolArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RunToolArguments -> RunToolArguments -> Bool
== :: RunToolArguments -> RunToolArguments -> Bool
$c/= :: RunToolArguments -> RunToolArguments -> Bool
/= :: RunToolArguments -> RunToolArguments -> Bool
Eq, Int -> RunToolArguments -> ShowS
[RunToolArguments] -> ShowS
RunToolArguments -> [Char]
(Int -> RunToolArguments -> ShowS)
-> (RunToolArguments -> [Char])
-> ([RunToolArguments] -> ShowS)
-> Show RunToolArguments
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RunToolArguments -> ShowS
showsPrec :: Int -> RunToolArguments -> ShowS
$cshow :: RunToolArguments -> [Char]
show :: RunToolArguments -> [Char]
$cshowList :: [RunToolArguments] -> ShowS
showList :: [RunToolArguments] -> ShowS
Show)

instance HasInputSchema RunToolArguments where
  toInputSchema :: Proxy RunToolArguments -> Value
toInputSchema Proxy RunToolArguments
_ =
    [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
"mainFunctionName"
                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 main function to run, e.g. `main` or `mynamespace.myprogram`." :: Text)
                  ],
              Key
"args"
                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
"An argument to pass to the main function." :: 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 arguments to pass to the main function." :: 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
"mainFunctionName", Text
"args" :: Text]
      ]

instance FromJSON RunToolArguments where
  parseJSON :: Value -> Parser RunToolArguments
parseJSON = [Char]
-> (Object -> Parser RunToolArguments)
-> Value
-> Parser RunToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"RunToolArguments" ((Object -> Parser RunToolArguments)
 -> Value -> Parser RunToolArguments)
-> (Object -> Parser RunToolArguments)
-> Value
-> Parser RunToolArguments
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
mainFunctionNameText <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"mainFunctionName"
    Name
mainFunctionName <- case Text -> Either Text Name
Name.parseTextEither Text
mainFunctionNameText 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 main function name: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
err
      Right Name
name -> Name -> Parser Name
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Name
name
    [Text]
args <- Object
o Object -> Key -> Parser [Text]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"args"
    RunToolArguments -> Parser RunToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RunToolArguments -> Parser RunToolArguments)
-> RunToolArguments -> Parser RunToolArguments
forall a b. (a -> b) -> a -> b
$ RunToolArguments {ProjectContext
$sel:projectContext:RunToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, Name
$sel:mainFunctionName:RunToolArguments :: Name
mainFunctionName :: Name
mainFunctionName, [Text]
$sel:args:RunToolArguments :: [Text]
args :: [Text]
args}

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}

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

instance HasInputSchema TestToolArguments where
  toInputSchema :: Proxy TestToolArguments -> Value
toInputSchema Proxy TestToolArguments
_ =
    [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
"subnamespace"
                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
"An optional subnamespace within the project to run tests in. E.g. `mynamespace.tests`. If null, tests in the entire project will be run." :: 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]
      ]

instance FromJSON TestToolArguments where
  parseJSON :: Value -> Parser TestToolArguments
parseJSON = [Char]
-> (Object -> Parser TestToolArguments)
-> Value
-> Parser TestToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"TestToolArguments" ((Object -> Parser TestToolArguments)
 -> Value -> Parser TestToolArguments)
-> (Object -> Parser TestToolArguments)
-> Value
-> Parser TestToolArguments
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"
    Maybe Path
subnamespace <- (Text -> Path) -> Maybe Text -> Maybe Path
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> Path
Path.unsafeParseText (Maybe Text -> Maybe Path)
-> Parser (Maybe Text) -> Parser (Maybe Path)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"subnamespace")
    TestToolArguments -> Parser TestToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TestToolArguments -> Parser TestToolArguments)
-> TestToolArguments -> Parser TestToolArguments
forall a b. (a -> b) -> a -> b
$ TestToolArguments {ProjectContext
$sel:projectContext:TestToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, Maybe Path
$sel:subnamespace:TestToolArguments :: Maybe Path
subnamespace :: Maybe Path
subnamespace}

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

instance HasInputSchema DeleteDefinitionsToolArguments where
  toInputSchema :: Proxy DeleteDefinitionsToolArguments -> Value
toInputSchema Proxy DeleteDefinitionsToolArguments
_ =
    [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
"A definition name to delete, e.g. `mynamespace.foo` or `MyType`." :: 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 delete." :: Text)
                  ],
              Key
"force"
                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
"boolean" :: Text),
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"If true, force delete even if the definition has dependents. Default is false." :: 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 DeleteDefinitionsToolArguments where
  parseJSON :: Value -> Parser DeleteDefinitionsToolArguments
parseJSON = [Char]
-> (Object -> Parser DeleteDefinitionsToolArguments)
-> Value
-> Parser DeleteDefinitionsToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"DeleteDefinitionsToolArguments" ((Object -> Parser DeleteDefinitionsToolArguments)
 -> Value -> Parser DeleteDefinitionsToolArguments)
-> (Object -> Parser DeleteDefinitionsToolArguments)
-> Value
-> Parser DeleteDefinitionsToolArguments
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"
    Bool
force <- Object
o Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"force" Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
    DeleteDefinitionsToolArguments
-> Parser DeleteDefinitionsToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (DeleteDefinitionsToolArguments
 -> Parser DeleteDefinitionsToolArguments)
-> DeleteDefinitionsToolArguments
-> Parser DeleteDefinitionsToolArguments
forall a b. (a -> b) -> a -> b
$ DeleteDefinitionsToolArguments {ProjectContext
$sel:projectContext:DeleteDefinitionsToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, [Name]
$sel:names:DeleteDefinitionsToolArguments :: [Name]
names :: [Name]
names, Bool
$sel:force:DeleteDefinitionsToolArguments :: Bool
force :: Bool
force}

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

instance HasInputSchema RenameDefinitionToolArguments where
  toInputSchema :: Proxy RenameDefinitionToolArguments -> Value
toInputSchema Proxy RenameDefinitionToolArguments
_ =
    [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
"oldName"
                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 current name of the definition to rename, e.g. `mynamespace.foo` or `MyType`." :: Text)
                  ],
              Key
"newNameSegment"
                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 new name segment (final part only). For example, to rename `foo.bar` to `foo.baz`, provide `baz`. The parent path is preserved." :: 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
"oldName", Text
"newNameSegment" :: Text]
      ]

instance FromJSON RenameDefinitionToolArguments where
  parseJSON :: Value -> Parser RenameDefinitionToolArguments
parseJSON = [Char]
-> (Object -> Parser RenameDefinitionToolArguments)
-> Value
-> Parser RenameDefinitionToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"RenameDefinitionToolArguments" ((Object -> Parser RenameDefinitionToolArguments)
 -> Value -> Parser RenameDefinitionToolArguments)
-> (Object -> Parser RenameDefinitionToolArguments)
-> Value
-> Parser RenameDefinitionToolArguments
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
oldName <- 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
"oldName"
    NameSegment
newNameSegment <- Text -> NameSegment
NameSegment.unsafeParseText (Text -> NameSegment) -> Parser Text -> Parser NameSegment
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
"newNameSegment"
    RenameDefinitionToolArguments
-> Parser RenameDefinitionToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (RenameDefinitionToolArguments
 -> Parser RenameDefinitionToolArguments)
-> RenameDefinitionToolArguments
-> Parser RenameDefinitionToolArguments
forall a b. (a -> b) -> a -> b
$ RenameDefinitionToolArguments {ProjectContext
$sel:projectContext:RenameDefinitionToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, Name
$sel:oldName:RenameDefinitionToolArguments :: Name
oldName :: Name
oldName, NameSegment
$sel:newNameSegment:RenameDefinitionToolArguments :: NameSegment
newNameSegment :: NameSegment
newNameSegment}

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

instance HasInputSchema MoveDefinitionToolArguments where
  toInputSchema :: Proxy MoveDefinitionToolArguments -> Value
toInputSchema Proxy MoveDefinitionToolArguments
_ =
    [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
"oldName"
                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 current full path of the definition to move, e.g. `mynamespace.foo` or `MyType`." :: Text)
                  ],
              Key
"newName"
                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 new full path for the definition, e.g. `othernamespace.bar` or `NewType`. Can move to a different namespace." :: 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
"oldName", Text
"newName" :: Text]
      ]

instance FromJSON MoveDefinitionToolArguments where
  parseJSON :: Value -> Parser MoveDefinitionToolArguments
parseJSON = [Char]
-> (Object -> Parser MoveDefinitionToolArguments)
-> Value
-> Parser MoveDefinitionToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"MoveDefinitionToolArguments" ((Object -> Parser MoveDefinitionToolArguments)
 -> Value -> Parser MoveDefinitionToolArguments)
-> (Object -> Parser MoveDefinitionToolArguments)
-> Value
-> Parser MoveDefinitionToolArguments
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
oldName <- 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
"oldName"
    Name
newName <- 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
"newName"
    MoveDefinitionToolArguments -> Parser MoveDefinitionToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MoveDefinitionToolArguments -> Parser MoveDefinitionToolArguments)
-> MoveDefinitionToolArguments
-> Parser MoveDefinitionToolArguments
forall a b. (a -> b) -> a -> b
$ MoveDefinitionToolArguments {ProjectContext
$sel:projectContext:MoveDefinitionToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, Name
$sel:oldName:MoveDefinitionToolArguments :: Name
oldName :: Name
oldName, Name
$sel:newName:MoveDefinitionToolArguments :: Name
newName :: Name
newName}

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

instance HasInputSchema MoveToToolArguments where
  toInputSchema :: Proxy MoveToToolArguments -> Value
toInputSchema Proxy MoveToToolArguments
_ =
    [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
"sources"
                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
"A path to move, e.g. `mynamespace.foo` or `MyType`." :: 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 paths of the definitions or namespaces to move. The final segment of each source is preserved in the destination." :: Text),
                    Key
"minItems" Key -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Int
1 :: Int)
                  ],
              Key
"destination"
                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 destination namespace to move the sources into, e.g. `othernamespace` or `foo.bar`. Each source's final segment is preserved." :: 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
"sources", Text
"destination" :: Text]
      ]

instance FromJSON MoveToToolArguments where
  parseJSON :: Value -> Parser MoveToToolArguments
parseJSON = [Char]
-> (Object -> Parser MoveToToolArguments)
-> Value
-> Parser MoveToToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"MoveToToolArguments" ((Object -> Parser MoveToToolArguments)
 -> Value -> Parser MoveToToolArguments)
-> (Object -> Parser MoveToToolArguments)
-> Value
-> Parser MoveToToolArguments
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"
    [Path']
sources <- (Text -> Path') -> [Text] -> [Path']
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> Path'
Path.unsafeParseText' ([Text] -> [Path']) -> Parser [Text] -> Parser [Path']
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
"sources"
    Path'
destination <- Text -> Path'
Path.unsafeParseText' (Text -> Path') -> Parser Text -> Parser Path'
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
"destination"
    MoveToToolArguments -> Parser MoveToToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MoveToToolArguments -> Parser MoveToToolArguments)
-> MoveToToolArguments -> Parser MoveToToolArguments
forall a b. (a -> b) -> a -> b
$ MoveToToolArguments {ProjectContext
$sel:projectContext:MoveToToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, [Path']
$sel:sources:MoveToToolArguments :: [Path']
sources :: [Path']
sources, Path'
$sel:destination:MoveToToolArguments :: Path'
destination :: Path'
destination}

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

instance HasInputSchema DeleteNamespaceToolArguments where
  toInputSchema :: Proxy DeleteNamespaceToolArguments -> Value
toInputSchema Proxy DeleteNamespaceToolArguments
_ =
    [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
"namespaceName"
                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 namespace to delete, e.g. `mynamespace` or `foo.bar`. This will delete the namespace and all definitions within it." :: Text)
                  ],
              Key
"force"
                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
"boolean" :: Text),
                    Key
"description" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
forall v. ToJSON v => Key -> v -> Pair
.= (Text
"If true, force delete even if definitions in the namespace have dependents. Default is false." :: 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
"namespaceName" :: Text]
      ]

instance FromJSON DeleteNamespaceToolArguments where
  parseJSON :: Value -> Parser DeleteNamespaceToolArguments
parseJSON = [Char]
-> (Object -> Parser DeleteNamespaceToolArguments)
-> Value
-> Parser DeleteNamespaceToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"DeleteNamespaceToolArguments" ((Object -> Parser DeleteNamespaceToolArguments)
 -> Value -> Parser DeleteNamespaceToolArguments)
-> (Object -> Parser DeleteNamespaceToolArguments)
-> Value
-> Parser DeleteNamespaceToolArguments
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
namespaceName <- 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
"namespaceName"
    Bool
force <- Object
o Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"force" Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
    DeleteNamespaceToolArguments -> Parser DeleteNamespaceToolArguments
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (DeleteNamespaceToolArguments
 -> Parser DeleteNamespaceToolArguments)
-> DeleteNamespaceToolArguments
-> Parser DeleteNamespaceToolArguments
forall a b. (a -> b) -> a -> b
$ DeleteNamespaceToolArguments {ProjectContext
$sel:projectContext:DeleteNamespaceToolArguments :: ProjectContext
projectContext :: ProjectContext
projectContext, Name
$sel:namespaceName:DeleteNamespaceToolArguments :: Name
namespaceName :: Name
namespaceName, Bool
$sel:force:DeleteNamespaceToolArguments :: Bool
force :: Bool
force}

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