{-# LANGUAGE NoFieldSelectors #-}

module Unison.MCP.Types
  ( MCP (..),
    Env (..),
    runMCP,
    ToolKind (..),
    ProjectCodeToolArguments (..),
    LibInstallToolArguments (..),
    ShareProjectSearchToolArguments (..),
    ShareProjectInfoToolArguments (..),
    TypecheckCodeToolArguments (..),
    ShareProjectReadmeToolArguments (..),
    ListLibraryDefinitionsToolArguments (..),
    ViewDefinitionsToolArguments (..),
    UpdateDefinitionsToolArguments (..),
    DiffUpdateToolArguments (..),
    SearchDefinitionsToolArguments (..),
    SearchByTypeToolArguments (..),
    DocsToolArguments (..),
    RunToolArguments (..),
    ProjectContext (..),
    ProjectContextArgument (..),
    ProjectNameArgument (..),
    ProjectDefinitionNameArgument (..),
    TestToolArguments (..),
    DeleteDefinitionsToolArguments (..),
    RenameDefinitionToolArguments (..),
    MoveDefinitionToolArguments (..),
    MoveToToolArguments (..),
    DeleteNamespaceToolArguments (..),
    ReflogToolArguments (..),
    HistoryToolArguments (..),
    CreateBranchToolArguments (..),
    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
  | ShareProjectInfoTool
  | TypecheckCodeTool
  | DocsTool
  | RunTool
  | ListProjectDefinitionsTool
  | ListProjectLibrariesTool
  | ListLibraryDefinitionsTool
  | ViewDefinitionsTool
  | UpdateDefinitionsTool
  | SearchDefinitionsTool
  | SearchByTypeTool
  | ListLocalProjectsTool
  | ListProjectBranchesTool
  | GetCurrentProjectContextTool
  | DependenciesTool
  | DependentsTool
  | TestsTool
  | DeleteDefinitionsTool
  | RenameDefinitionTool
  | MoveDefinitionTool
  | MoveToTool
  | DeleteNamespaceTool
  | DiffUpdateTool
  | ReflogTool
  | HistoryTool
  | CreateBranchTool
  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
ShareProjectInfoTool, Text
"share-project-info"),
      (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"),
      (ToolKind
ReflogTool, Text
"reflog"),
      (ToolKind
HistoryTool, Text
"history"),
      (ToolKind
CreateBranchTool, Text
"create-branch")
    ]

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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"definitionName"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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
    definitionNameText <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"definitionName"
    definitionName <- case Name.parseTextEither 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 <- o .: "projectContext"
    pure $ ProjectDefinitionNameArgument {definitionName, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    pure $ ProjectContextArgument 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectName"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The name of a project to work within, e.g. `@unison/base` or `@ceedubs/json`" :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- 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"
    pure $ ProjectNameArgument {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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"A type to search for, e.g. `[Nat] -> Nat`." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    query <- o .: "query"
    pure $ SearchByTypeToolArguments {projectContext, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"A name to search for, e.g. `foldl`." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    query <- o .: "query"
    pure $ SearchDefinitionsToolArguments {projectContext, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"array" :: Text),
                    Key
"items"
                      Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                        [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                          Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The names of the definitions to view." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    names <- fmap Name.unsafeParseText <$> o .: "names"
    pure $ ViewDefinitionsToolArguments {projectContext, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
                    Key
"properties"
                      Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                        [ Key
"sourceCode"
                            Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                              [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                                Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The source code to update definitions to." :: Text)
                              ],
                          Key
"filePath"
                            Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                              [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                                Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The absolute file path to the source code." :: Text)
                              ]
                        ],
                    Key
"additionalProperties" Key -> Bool -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Bool
False,
                    Key
"minProperties" Key -> Int -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Int
1 :: Int),
                    Key
"maxProperties" Key -> Int -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Int
1 :: Int)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    source <- o .: "code"
    mFilePath <- source .:? "filePath"
    mSourceCode <- source .:? "sourceCode"
    mText <- source .:? "text"
    let 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])
    when (providedCount == 0) $
      fail "Expected one of: code.filePath, code.sourceCode"
    when (providedCount > 1) $
      fail "Expected exactly one of: code.filePath, code.sourceCode"
    code <- case (mFilePath, mSourceCode, 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"
    pure $ UpdateDefinitionsToolArguments {projectContext, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [ [Pair] -> Value
object
                             [ Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The file path to the source code." :: Text),
                               Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
                               Key
"properties"
                                 Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                                   [ Key
"filePath"
                                       Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                                         [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                                           Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"An absolute file path to the source code." :: Text)
                                         ]
                                   ],
                               Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Text
"filePath" :: Text],
                               Key
"additionalProperties" Key -> Bool -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Bool
False
                             ],
                           [Pair] -> Value
object
                             [ Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The source code to use." :: Text),
                               Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
                               Key
"properties"
                                 Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                                   [ Key
"text"
                                       Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                                         [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                                           Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The source code." :: Text)
                                         ]
                                   ],
                               Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Text
"text" :: Text],
                               Key
"additionalProperties" Key -> Bool -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Bool
False
                             ]
                         ]
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    source <- o .: "code"
    code <-
      source .:? "filePath" >>= \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 <- Object
source Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"text"
          pure $ Right text
    pure $ DiffUpdateToolArguments {projectContext, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The name of the library to list definitions for, e.g. `base` or `json`." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    libName <- o .: "libName"
    pure $ ListLibraryDefinitionsToolArguments {projectContext, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectName"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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
    projectName <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectName"
    projectOwnerHandle <- o .: "projectOwnerHandle"
    pure $ ShareProjectReadmeToolArguments {projectName, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The source code to typecheck. Either the `sourceCode` key or the `filePath`, but not both." :: Text),
                    Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
                    Key
"properties"
                      Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                        [ Key
"sourceCode"
                            Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                              [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                                Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The source code to typecheck." :: Text)
                              ],
                          Key
"filePath"
                            Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                              [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                                Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The absolute file path to the source code to typecheck." :: Text)
                              ]
                        ],
                    Key
"additionalProperties" Key -> Bool -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Bool
False,
                    Key
"minProperties" Key -> Int -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Int
1 :: Int),
                    Key
"maxProperties" Key -> Int -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Int
1 :: Int)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    source <- o .: "code"
    source .:? "filePath" >>= \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
projectContext :: ProjectContext
projectContext :: ProjectContext
projectContext, code :: Either [Char] Text
code = [Char] -> Either [Char] Text
forall a b. a -> Either a b
Left [Char]
filePath}
      Maybe [Char]
Nothing -> do
        text <- Object
source Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sourceCode"
        pure $ TypecheckCodeToolArguments {projectContext, code = Right 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"name"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The definition name to fetch documentation for. E.g. `README` or `data.Map.fromList`" :: Text)
                  ],
              Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    name <- Name.unsafeParseText <$> o .: "name"
    pure $ DocsToolArguments {projectContext, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The name of the main function to run, e.g. `main` or `mynamespace.myprogram`." :: Text)
                  ],
              Key
"args"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"array" :: Text),
                    Key
"items"
                      Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                        [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                          Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"An argument to pass to the main function." :: Text)
                        ],
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The arguments to pass to the main function." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    mainFunctionNameText <- o .: "mainFunctionName"
    mainFunctionName <- case Name.parseTextEither 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
    args <- o .: "args"
    pure $ RunToolArguments {projectContext, mainFunctionName, 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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    pure $ ProjectCodeToolArguments {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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectName"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The name of the project to work within, e.g. `@unison/base` or `@ceedubs/json`" :: Text)
                  ],
              Key
"branchName"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The branch of the project to work within, e.g. `main` or `develop`" :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- 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"
    branchName <- UnsafeProjectBranchName <$> o .: "branchName"
    pure $ ProjectContext {projectName, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
projectName,
        Key
"branchName" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    libProjectName <- o .: "libProjectName"
    libBranchName <- o .:? "libBranchName"
    pure $
      LibInstallToolArguments
        { projectContext,
          libProjectName,
          libBranchName
        }

instance HasInputSchema LibInstallToolArguments where
  toInputSchema :: Proxy LibInstallToolArguments -> Value
toInputSchema Proxy LibInstallToolArguments
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The name of the library project to install" :: Text)
                  ],
              Key
"libBranchName"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Text
"string" :: Text, Text
"null"],
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"query"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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
    query <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query"
    pure $ ShareProjectSearchToolArguments {query}

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

instance HasInputSchema ShareProjectInfoToolArguments where
  toInputSchema :: Proxy ShareProjectInfoToolArguments -> Value
toInputSchema Proxy ShareProjectInfoToolArguments
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectName"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The full project name including owner, e.g. `@unison/base` or `@owner/project-name`" :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Text
"projectName" :: Text]
      ]

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

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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Text
"string" :: Text, Text
"null"],
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    subnamespace <- fmap Path.unsafeParseText <$> (o .:? "subnamespace")
    pure $ TestToolArguments {projectContext, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"array" :: Text),
                    Key
"items"
                      Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                        [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                          Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"A definition name to delete, e.g. `mynamespace.foo` or `MyType`." :: Text)
                        ],
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The names of the definitions to delete." :: Text)
                  ],
              Key
"force"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"boolean" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"If true, force delete even if the definition has dependents. Default is false." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    names <- fmap Name.unsafeParseText <$> o .: "names"
    force <- o .:? "force" .!= False
    pure $ DeleteDefinitionsToolArguments {projectContext, names, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The current name of the definition to rename, e.g. `mynamespace.foo` or `MyType`." :: Text)
                  ],
              Key
"newNameSegment"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    oldName <- Name.unsafeParseText <$> o .: "oldName"
    newNameSegment <- NameSegment.unsafeParseText <$> o .: "newNameSegment"
    pure $ RenameDefinitionToolArguments {projectContext, oldName, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The current full path of the definition to move, e.g. `mynamespace.foo` or `MyType`." :: Text)
                  ],
              Key
"newName"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    oldName <- Name.unsafeParseText <$> o .: "oldName"
    newName <- Name.unsafeParseText <$> o .: "newName"
    pure $ MoveDefinitionToolArguments {projectContext, oldName, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"array" :: Text),
                    Key
"items"
                      Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                        [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                          Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"A path to move, e.g. `mynamespace.foo` or `MyType`." :: Text)
                        ],
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Int
1 :: Int)
                  ],
              Key
"destination"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    sources <- fmap Path.unsafeParseText' <$> o .: "sources"
    destination <- Path.unsafeParseText' <$> o .: "destination"
    pure $ MoveToToolArguments {projectContext, sources, 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (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 v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"boolean" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"If true, force delete even if definitions in the namespace have dependents. Default is false." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [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 <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    namespaceName <- Name.unsafeParseText <$> o .: "namespaceName"
    force <- o .:? "force" .!= False
    pure $ DeleteNamespaceToolArguments {projectContext, namespaceName, force}

-- | Arguments for the reflog tool
data ReflogToolArguments = ReflogToolArguments
  { ReflogToolArguments -> ProjectContext
projectContext :: ProjectContext,
    ReflogToolArguments -> Maybe Text
scope :: Maybe Text, -- "branch" | "project" | "global", default "branch"
    ReflogToolArguments -> Maybe Int
limit :: Maybe Int,
    ReflogToolArguments -> Maybe Bool
includeTimestamps :: Maybe Bool -- default True
  }
  deriving (ReflogToolArguments -> ReflogToolArguments -> Bool
(ReflogToolArguments -> ReflogToolArguments -> Bool)
-> (ReflogToolArguments -> ReflogToolArguments -> Bool)
-> Eq ReflogToolArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReflogToolArguments -> ReflogToolArguments -> Bool
== :: ReflogToolArguments -> ReflogToolArguments -> Bool
$c/= :: ReflogToolArguments -> ReflogToolArguments -> Bool
/= :: ReflogToolArguments -> ReflogToolArguments -> Bool
Eq, Int -> ReflogToolArguments -> ShowS
[ReflogToolArguments] -> ShowS
ReflogToolArguments -> [Char]
(Int -> ReflogToolArguments -> ShowS)
-> (ReflogToolArguments -> [Char])
-> ([ReflogToolArguments] -> ShowS)
-> Show ReflogToolArguments
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ReflogToolArguments -> ShowS
showsPrec :: Int -> ReflogToolArguments -> ShowS
$cshow :: ReflogToolArguments -> [Char]
show :: ReflogToolArguments -> [Char]
$cshowList :: [ReflogToolArguments] -> ShowS
showList :: [ReflogToolArguments] -> ShowS
Show)

instance HasInputSchema ReflogToolArguments where
  toInputSchema :: Proxy ReflogToolArguments -> Value
toInputSchema Proxy ReflogToolArguments
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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
"scope"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"enum" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ([Text
"branch", Text
"project", Text
"global"] :: [Text]),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The scope of the reflog: 'branch' (default) shows entries for the current branch, 'project' shows entries for all branches in the project, 'global' shows entries for all projects." :: Text)
                  ],
              Key
"limit"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"integer" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"Maximum number of entries to return. Default is 100." :: Text)
                  ],
              Key
"includeTimestamps"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"boolean" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"Whether to include timestamps in the output. Default is true." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Text
"projectContext" :: Text]
      ]

instance FromJSON ReflogToolArguments where
  parseJSON :: Value -> Parser ReflogToolArguments
parseJSON = [Char]
-> (Object -> Parser ReflogToolArguments)
-> Value
-> Parser ReflogToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"ReflogToolArguments" ((Object -> Parser ReflogToolArguments)
 -> Value -> Parser ReflogToolArguments)
-> (Object -> Parser ReflogToolArguments)
-> Value
-> Parser ReflogToolArguments
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    projectContext <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    scope <- o .:? "scope"
    limit <- o .:? "limit"
    includeTimestamps <- o .:? "includeTimestamps"
    pure $ ReflogToolArguments {projectContext, scope, limit, includeTimestamps}

-- | Arguments for the history tool
data HistoryToolArguments = HistoryToolArguments
  { HistoryToolArguments -> ProjectContext
projectContext :: ProjectContext,
    HistoryToolArguments -> Maybe Text
startHash :: Maybe Text, -- optional starting causal hash
    HistoryToolArguments -> Maybe Int
limit :: Maybe Int,
    HistoryToolArguments -> Maybe Int
diffLimit :: Maybe Int
  }
  deriving (HistoryToolArguments -> HistoryToolArguments -> Bool
(HistoryToolArguments -> HistoryToolArguments -> Bool)
-> (HistoryToolArguments -> HistoryToolArguments -> Bool)
-> Eq HistoryToolArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HistoryToolArguments -> HistoryToolArguments -> Bool
== :: HistoryToolArguments -> HistoryToolArguments -> Bool
$c/= :: HistoryToolArguments -> HistoryToolArguments -> Bool
/= :: HistoryToolArguments -> HistoryToolArguments -> Bool
Eq, Int -> HistoryToolArguments -> ShowS
[HistoryToolArguments] -> ShowS
HistoryToolArguments -> [Char]
(Int -> HistoryToolArguments -> ShowS)
-> (HistoryToolArguments -> [Char])
-> ([HistoryToolArguments] -> ShowS)
-> Show HistoryToolArguments
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HistoryToolArguments -> ShowS
showsPrec :: Int -> HistoryToolArguments -> ShowS
$cshow :: HistoryToolArguments -> [Char]
show :: HistoryToolArguments -> [Char]
$cshowList :: [HistoryToolArguments] -> ShowS
showList :: [HistoryToolArguments] -> ShowS
Show)

instance HasInputSchema HistoryToolArguments where
  toInputSchema :: Proxy HistoryToolArguments -> Value
toInputSchema Proxy HistoryToolArguments
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectContext" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= 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
"startHash"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"Optional causal hash to start history from. If not provided, starts from the current branch head." :: Text)
                  ],
              Key
"limit"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"integer" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"Maximum number of history entries to return. Default is 100." :: Text)
                  ],
              Key
"diffLimit"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"integer" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"Maximum number of diff elements to show per entry. Default is 10." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Text
"projectContext" :: Text]
      ]

instance FromJSON HistoryToolArguments where
  parseJSON :: Value -> Parser HistoryToolArguments
parseJSON = [Char]
-> (Object -> Parser HistoryToolArguments)
-> Value
-> Parser HistoryToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"HistoryToolArguments" ((Object -> Parser HistoryToolArguments)
 -> Value -> Parser HistoryToolArguments)
-> (Object -> Parser HistoryToolArguments)
-> Value
-> Parser HistoryToolArguments
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    projectContext <- Object
o Object -> Key -> Parser ProjectContext
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"projectContext"
    startHash <- o .:? "startHash"
    limit <- o .:? "limit"
    diffLimit <- o .:? "diffLimit"
    pure $ HistoryToolArguments {projectContext, startHash, limit, diffLimit}

-- | Arguments for the create-branch tool
data CreateBranchToolArguments = CreateBranchToolArguments
  { CreateBranchToolArguments -> ProjectName
projectName :: ProjectName,
    CreateBranchToolArguments -> ProjectBranchName
newBranchName :: ProjectBranchName,
    CreateBranchToolArguments -> Text
sourceType :: Text, -- "current" | "empty" | "branch"
    CreateBranchToolArguments -> Maybe ProjectName
sourceBranchProject :: Maybe ProjectName,
    CreateBranchToolArguments -> Maybe ProjectBranchName
sourceBranchName :: Maybe ProjectBranchName
  }
  deriving (CreateBranchToolArguments -> CreateBranchToolArguments -> Bool
(CreateBranchToolArguments -> CreateBranchToolArguments -> Bool)
-> (CreateBranchToolArguments -> CreateBranchToolArguments -> Bool)
-> Eq CreateBranchToolArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CreateBranchToolArguments -> CreateBranchToolArguments -> Bool
== :: CreateBranchToolArguments -> CreateBranchToolArguments -> Bool
$c/= :: CreateBranchToolArguments -> CreateBranchToolArguments -> Bool
/= :: CreateBranchToolArguments -> CreateBranchToolArguments -> Bool
Eq, Int -> CreateBranchToolArguments -> ShowS
[CreateBranchToolArguments] -> ShowS
CreateBranchToolArguments -> [Char]
(Int -> CreateBranchToolArguments -> ShowS)
-> (CreateBranchToolArguments -> [Char])
-> ([CreateBranchToolArguments] -> ShowS)
-> Show CreateBranchToolArguments
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CreateBranchToolArguments -> ShowS
showsPrec :: Int -> CreateBranchToolArguments -> ShowS
$cshow :: CreateBranchToolArguments -> [Char]
show :: CreateBranchToolArguments -> [Char]
$cshowList :: [CreateBranchToolArguments] -> ShowS
showList :: [CreateBranchToolArguments] -> ShowS
Show)

instance HasInputSchema CreateBranchToolArguments where
  toInputSchema :: Proxy CreateBranchToolArguments -> Value
toInputSchema Proxy CreateBranchToolArguments
_ =
    [Pair] -> Value
object
      [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"object" :: Text),
        Key
"properties"
          Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
            [ Key
"projectName"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The name of the project to create the branch in, e.g. `@unison/base` or `@ceedubs/json`" :: Text)
                  ],
              Key
"newBranchName"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The name for the new branch, e.g. `feature/my-feature` or `develop`" :: Text)
                  ],
              Key
"sourceType"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"string" :: Text),
                    Key
"enum" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ([Text
"current", Text
"empty", Text
"branch"] :: [Text]),
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"The source for the new branch: 'current' creates from current context, 'empty' creates an empty branch, 'branch' creates from an existing branch specified by sourceBranchProject and sourceBranchName" :: Text)
                  ],
              Key
"sourceBranchProject"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Text
"string" :: Text, Text
"null"],
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"When sourceType is 'branch', the project containing the source branch. Optional - defaults to the target project if not specified." :: Text)
                  ],
              Key
"sourceBranchName"
                Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object
                  [ Key
"type" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Text
"string" :: Text, Text
"null"],
                    Key
"description" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"When sourceType is 'branch', the name of the source branch to copy from." :: Text)
                  ]
            ],
        Key
"required" Key -> [Text] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Text
"projectName", Text
"newBranchName", Text
"sourceType" :: Text]
      ]

instance FromJSON CreateBranchToolArguments where
  parseJSON :: Value -> Parser CreateBranchToolArguments
parseJSON = [Char]
-> (Object -> Parser CreateBranchToolArguments)
-> Value
-> Parser CreateBranchToolArguments
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"CreateBranchToolArguments" ((Object -> Parser CreateBranchToolArguments)
 -> Value -> Parser CreateBranchToolArguments)
-> (Object -> Parser CreateBranchToolArguments)
-> Value
-> Parser CreateBranchToolArguments
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    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"
    newBranchName <- UnsafeProjectBranchName <$> o .: "newBranchName"
    sourceType <- o .: "sourceType"
    sourceBranchProject <- fmap UnsafeProjectName <$> o .:? "sourceBranchProject"
    sourceBranchName <- fmap UnsafeProjectBranchName <$> o .:? "sourceBranchName"
    pure $ CreateBranchToolArguments {projectName, newBranchName, sourceType, sourceBranchProject, sourceBranchName}

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