diff --git a/src/Cabal.hs b/src/Cabal.hs
new file mode 100644
index 0000000..b7c7e7b
--- /dev/null
+++ b/src/Cabal.hs
@@ -0,0 +1,38 @@
+{-# LANGUAGE RecordWildCards #-}
+
+module Cabal (buildTargetSrcDirs) where
+
+import Data.List
+import Distribution.Package
+import Distribution.PackageDescription
+import Distribution.PackageDescription.Parse
+import Distribution.Verbosity
+
+type BuildTargetName = String
+type SrcDirs = String
+type Cond a = (BuildTargetName, CondTree ConfVar [Dependency] a)
+
+------------------------------------------------------------------------------
+buildTargetSrcDirs :: FilePath -> BuildTargetName -> IO (Maybe [SrcDirs])
+buildTargetSrcDirs cabalFilePath btn = do
+  gPDesc <- readPackageDescription silent cabalFilePath
+  return $ findSrcDirs gPDesc btn
+
+------------------------------------------------------------------------------
+findSrcDirs :: GenericPackageDescription -> BuildTargetName -> Maybe [SrcDirs]
+findSrcDirs GenericPackageDescription{..} btn =
+  case findTarget btn condExecutables of
+    Just execTarget -> Just . hsSourceDirs . buildInfo $ execTarget
+    Nothing         -> case findTarget btn condTestSuites of
+      Just testTarget -> Just . hsSourceDirs . testBuildInfo $ testTarget
+      Nothing         -> case findTarget btn condBenchmarks of
+        Just benchmarkTarget -> Just . hsSourceDirs . benchmarkBuildInfo $ benchmarkTarget
+        Nothing              -> Nothing
+
+------------------------------------------------------------------------------
+findTarget :: BuildTargetName -> [(Cond a)] -> Maybe a
+findTarget btn targets = do
+  (_, CondNode a _ _ ) <- find isBuildTarget targets
+  return a 
+  where
+    isBuildTarget (name, _) = name == btn          
diff --git a/src/Client.hs b/src/Client.hs
new file mode 100644
index 0000000..1816141
--- /dev/null
+++ b/src/Client.hs
@@ -0,0 +1,4 @@
+module Client (Client(..)) where
+
+data Client = SublimeText
+            | Emacs
diff --git a/src/HDevTools.hs b/src/HDevTools.hs
new file mode 100644
index 0000000..173f9bc
--- /dev/null
+++ b/src/HDevTools.hs
@@ -0,0 +1,51 @@
+module HDevTools (isInModuleScope) where
+
+import Control.Monad
+import Data.List
+import System.Exit
+import System.Process
+------------------------------------------------------------------------------
+import Cabal
+
+------------------------------------------------------------------------------
+type SymbolName = String
+
+------------------------------------------------------------------------------
+isInModuleScope :: FilePath -> FilePath -> FilePath -> String ->  SymbolName -> IO Bool
+isInModuleScope filePath pkgConfigPath cabalFilePath buildTargetName symName = do 
+  (exitCode, _, stderr) <- search
+  case exitCode of
+    ExitFailure _ -> return $ "Not in scope" `isInfixOf` stderr
+    _             -> return False
+  where
+    search = do
+      let packageConfigOption = ghcOptionPkgConfig pkgConfigPath
+      maybeOptionSrcDirs <- ghcOptionSrcDirs cabalFilePath buildTargetName 
+      case maybeOptionSrcDirs of
+        Just optionSrcDirs -> do 
+          let args = ["info", filePath, symName, packageConfigOption] ++ optionSrcDirs
+          readProcessWithExitCode hdevtools args ""
+        Nothing -> readProcessWithExitCode hdevtools ["info", filePath, symName, packageConfigOption]  ""
+                                                                         
+------------------------------------------------------------------------------
+ghcOptionSrcDirs :: String -> String ->  IO (Maybe [String])
+ghcOptionSrcDirs cabalFilePath buildTargetName = do 
+  maybeSrcDirs <- buildTargetSrcDirs cabalFilePath buildTargetName
+  case maybeSrcDirs of
+    Just srcDirs -> return $ Just $ map ghcOptionSrcDir srcDirs
+    Nothing      -> return $ Nothing
+
+
+------------------------------------------------------------------------------
+hdevtools :: String           
+hdevtools = "hdevtools"
+
+------------------------------------------------------------------------------
+ghcOptionPkgConfig :: String -> String
+ghcOptionPkgConfig =  (++) "-g-package-conf"
+
+------------------------------------------------------------------------------
+ghcOptionSrcDir :: String -> String
+ghcOptionSrcDir = (++) "-g-i"
+
+fn = isInModuleScope "src/HSrcQuery.hs" ".cabal-sandbox/x86_64-linux-ghc-7.6.3-packages.conf.d/" "haskell-src-query.cabal" "haskell-src-query" "runQuery"
diff --git a/src/HLint.hs b/src/HLint.hs
new file mode 100644
index 0000000..5a33c21
--- /dev/null
+++ b/src/HLint.hs
@@ -0,0 +1,56 @@
+{-# LANGUAGE RecordWildCards #-}
+
+module HLint (hlint) where
+
+import Control.Applicative
+import Data.Maybe
+import Temporary.API
+import Language.Haskell.Exts.Annotated (SrcSpan(..))
+
+------------------------------------------------------------------------------
+hlint :: String -> IO String
+hlint code = do
+ ideas <- genIdeas code
+ if length ideas > 0 
+   then return $ serializeIdeas ideas
+   else return "[]"
+
+------------------------------------------------------------------------------
+genIdeas :: String -> IO [Idea]
+genIdeas code =  do 
+  (parseFlags, classifications, hint) <- autoSettings
+  eitherErrorModule <- parseModuleEx parseFlags "" (Just code)
+  case eitherErrorModule of
+     Left _    -> error "error parsing code" 
+     Right msi -> return $ applyHints classifications hint [msi]
+
+------------------------------------------------------------------------------
+serializeIdeas :: [Idea] -> String
+serializeIdeas ideas = "[" ++ (concat $ serializeIdea <$> ideas) ++ "]"
+
+------------------------------------------------------------------------------
+serializeIdea ::  Idea -> String
+serializeIdea idea = 
+  case ideaTo idea of
+    Just to -> "[" ++ concat (ideaContent to (ideaSpan idea)) ++ "]"
+    Nothing -> ""
+  where 
+    ideaContent to SrcSpan{..} =  
+       [ show . show $ ideaSeverity idea
+       , show $ findSuggestion (ideaHint idea)
+       , show $ ideaFrom idea 
+       , show to
+       , show . show $ srcSpanStartLine
+       , show . show $ srcSpanStartColumn
+       , show . show $ srcSpanEndLine
+       , show . show $ srcSpanEndColumn
+       ]
+             
+------------------------------------------------------------------------------
+findSuggestion :: String -> String
+findSuggestion i = fromMaybe "Error: No suggestion string mapping yet" $ 
+                  lookup i [ ("Redundant lambda", "remove redundant lambda")
+                           , ("Avoid lambda", "move lambda to top level")
+                           , ("Collapse lambdas", "collapse nested lambdas") 
+                           , ("Redundant bracket", "remove redundant bracket")
+                           ]
diff --git a/src/HSrcQuery.hs b/src/HSrcQuery.hs
new file mode 100644
index 0000000..3a1a381
--- /dev/null
+++ b/src/HSrcQuery.hs
@@ -0,0 +1,114 @@
+{-# LANGUAGE RecordWildCards #-}
+
+module Main where
+
+import Options.Applicative
+------------------------------------------------------------------------------
+import Client
+import HLint
+import Lambda
+import ParseAST
+
+------------------------------------------------------------------------------
+data Query = FreeVariables
+           | LambdaBody
+           | LambdaArgs
+           | HLint
+           | ParseAST
+             deriving Show
+
+------------------------------------------------------------------------------
+data Request = Request  { query            :: Query
+                        , client           :: Client
+                        , srcFilePath      :: FilePath
+                        , pkgConfigDirPath :: FilePath
+                        , cabalFilePath    :: FilePath
+                        , buildTargetName  :: String
+                        }
+
+------------------------------------------------------------------------------
+requestParser :: Parser Request 
+requestParser = Request <$> argument parseQueryArg
+                        ( metavar "QUERY"
+                          <> help "Query to run on selected code.")
+                  <*> argument parseClientArg
+                        ( metavar "CLIENT"
+                          <> help "Client Emacs or Sublime" )
+                  <*> strOption ( long "source-file"
+                                       <> metavar "FILE"
+                                       <> help "File containing selected code." 
+                                       <> value "")
+                  <*> strOption ( long "package-conf"
+                                       <> metavar "DIRECTORY"
+                                       <> help "GHC package config directory." 
+                                       <> value "")
+                  <*> strOption ( long "cabal-file"
+                                       <> metavar "FILE"
+                                       <> help "Cabal file" 
+                                       <> value "")
+                  <*> strOption ( long "build-target"
+                                       <> metavar "TARGET"
+                                       <> help "Target of build" 
+                                       <> value "")
+
+
+requestParserInfo :: ParserInfo Request
+requestParserInfo = info (helper <*> requestParser)
+                      ( fullDesc
+                      <> progDesc "Query infromation about Haskell source."
+                      <> header "haskell-src-query - get info about haskell src")
+                  
+------------------------------------------------------------------------------
+main :: IO ()
+main = do
+  Request{..} <- execParser requestParserInfo
+  code        <- getContents
+  putStrLn =<< runQuery query 
+                        srcFilePath 
+                        pkgConfigDirPath 
+                        cabalFilePath 
+                        buildTargetName
+                        client
+                        code
+
+------------------------------------------------------------------------------
+parseQueryArg :: String -> Maybe Query
+parseQueryArg s | s == "freeVariables" = Just FreeVariables
+                | s == "lambdaBody"    = Just LambdaBody
+                | s == "lambdaArgs"    = Just LambdaArgs
+                | s == "hlint"         = Just HLint
+                | s == "parse"         = Just ParseAST
+                | otherwise            = Nothing
+
+------------------------------------------------------------------------------
+parseClientArg :: String -> Maybe Client
+parseClientArg s | s == "SublimeText" = Just SublimeText
+                 | s == "Emacs"       = Just Emacs
+                 | otherwise          = Nothing
+
+------------------------------------------------------------------------------
+runQuery
+  :: Query
+     -> FilePath
+     -> FilePath
+     -> FilePath
+     -> String
+     -> Client
+     -> String
+     -> IO String
+runQuery FreeVariables srcFile 
+                       pkgConfigPath 
+                       cabalFilePath 
+                       buildTargetName 
+                       client 
+                       code = 
+  freeVariables srcFile 
+                pkgConfigPath
+                cabalFilePath
+                buildTargetName
+                client
+                code
+runQuery LambdaBody _ _ _ _ _ code = return $ lambdaBody code
+runQuery LambdaArgs _ _ _ _ _ code = return $ lambdaArgs code
+runQuery HLint      _ _ _ _ _ code = hlint code
+runQuery ParseAST   _ _ _ _ _ code = return $ parseAST code
diff --git a/src/Lambda.hs b/src/Lambda.hs
new file mode 100644
index 0000000..29fce06
--- /dev/null
+++ b/src/Lambda.hs
@@ -0,0 +1,90 @@
+module Lambda ( freeVariables
+              , lambdaArgs
+              , lambdaBody
+              ) where
+
+import Control.Monad
+import Data.Generics.Aliases
+import Data.Generics.Schemes
+import Data.List
+import Language.Haskell.Exts
+------------------------------------------------------------------------------
+import HDevTools
+import Client
+
+------------------------------------------------------------------------------
+freeVariables :: FilePath -> FilePath -> FilePath -> String -> Client -> String -> IO String
+freeVariables srcPath pkgConfigPath cabalFilePath buildTargetName client code = case parseExp code of
+  ParseOk ast -> do
+   names <- dropModuleVariableNames srcPath
+                                    pkgConfigPath
+                                    cabalFilePath
+                                    buildTargetName $ extractFreeVariables ast
+   return . dropCommas $ show names
+  _ -> return "Error parsing freeVars"
+
+------------------------------------------------------------------------------
+lambdaBody ::  String -> String
+lambdaBody code = case parseExp code of
+  ParseOk ast -> show . extractLambdaBody $ ast
+  _           -> "[]"
+
+------------------------------------------------------------------------------
+lambdaArgs :: String -> String
+lambdaArgs code = case parseExp code of
+  ParseOk ast -> extractLambdaArgs ast
+  _           -> "[]"
+
+------------------------------------------------------------------------------
+extractLambdaArgs :: Exp -> String
+extractLambdaArgs (Lambda _ ast _) = dropCommas . show $ allNames ast
+extractLambdaArgs _                = "[]"
+
+------------------------------------------------------------------------------
+allVariables :: GenericQ [Exp]
+allVariables = listify isVar
+
+------------------------------------------------------------------------------
+allBindings :: GenericQ [Pat]
+allBindings = listify isBinding
+
+------------------------------------------------------------------------------
+allNames :: GenericQ [String]
+allNames = everything (++) ([] `mkQ` fmap (: []) getStringFromName)
+
+------------------------------------------------------------------------------
+isVar :: Exp -> Bool
+isVar (Var  _) = True
+isVar  _       = False
+
+------------------------------------------------------------------------------
+isBinding :: Pat -> Bool
+isBinding (PVar _) = True
+isBinding _        = False
+
+------------------------------------------------------------------------------
+getStringFromName :: Name -> String
+getStringFromName (Symbol str) = str
+getStringFromName (Ident str)  = str
+
+------------------------------------------------------------------------------
+dropCommas :: String -> String
+dropCommas = filter (/= ',')
+
+------------------------------------------------------------------------------
+extractLambdaBody :: Exp -> String
+extractLambdaBody (Lambda _ _ ast) = prettyPrint ast
+extractLambdaBody _ = "[]"
+
+------------------------------------------------------------------------------
+extractFreeVariables :: GenericQ [String]
+extractFreeVariables ast = allNames (allVariables ast) \\
+                           allNames (allBindings ast)
+
+------------------------------------------------------------------------------
+dropModuleVariableNames :: FilePath -> FilePath -> FilePath -> String -> [String] -> IO [String]
+dropModuleVariableNames srcPath pkgConfigPath cabalFilePath buildTargetName  =
+  filterM $  (liftM not) .  isInModuleScope srcPath
+                                            pkgConfigPath
+                                            cabalFilePath
+                                            buildTargetName
diff --git a/src/ParseAST.hs b/src/ParseAST.hs
new file mode 100644
index 0000000..472f820
--- /dev/null
+++ b/src/ParseAST.hs
@@ -0,0 +1,135 @@
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE ExistentialQuantification #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module ParseAST (parseAST) where
+
+import Control.Applicative
+import Data.Data
+import Data.Maybe
+import Language.Haskell.Exts.Annotated
+
+-----------------------------------------------------------------------------------------
+data D = forall a. Data a => D a
+
+-----------------------------------------------------------------------------------------
+parseAST :: String -> [Char]
+parseAST code = case parseTopLevel parseMode code of
+  ParseOk (D ast) -> ("[" ++ concat (genHSE ast) ++ "]")
+  ParseFailed _ _ -> "[]"
+
+-----------------------------------------------------------------------------------------
+parseTopLevel :: ParseMode -> String -> ParseResult D 
+parseTopLevel mode code =
+  D . fix <$> parseDeclWithMode mode code   <|>
+  D       <$> parseImport mode code         <|>
+  D . fix <$> parseModuleWithMode mode code <|>
+  D       <$> parseModulePragma mode code
+
+-----------------------------------------------------------------------------------------
+-- | The 'empty' method isn't (shouldn't be) used, so this isn't a
+-- real Alternative instance (perhaps a Semigroup might do?). But it's
+-- handy.
+instance Alternative ParseResult where
+  empty = ParseFailed undefined undefined
+  ParseFailed{} <|> x = x
+  x <|> _             = x
+
+-----------------------------------------------------------------------------------------
+fix :: AppFixity ast => ast SrcSpanInfo -> ast SrcSpanInfo
+fix ast = fromMaybe ast (applyFixities baseFixities ast) 
+
+-----------------------------------------------------------------------------------------
+-- | Pre-children tweaks for a given parent at index i.
+--
+pre :: (Typeable a) => a -> Integer -> [String]
+pre x i =
+  case cast x of
+    -- <foo { <foo = 1> }> becomes <foo <{ <foo = 1> }>>
+    Just (RecUpdate SrcSpanInfo{srcInfoPoints=(start:_),srcInfoSpan=end} _ _)
+      | i == 1 ->
+        [spanHSE (show "RecUpdates")
+                 "RecUpdates"
+                 (SrcSpan (srcSpanFilename start)
+                          (srcSpanStartLine start)
+                          (srcSpanStartColumn start)
+                          (srcSpanEndLine end)
+                          (srcSpanEndColumn end))]
+    _ -> case cast x :: Maybe (Deriving SrcSpanInfo)  of
+           -- <deriving (X,Y,Z)> becomes <deriving (<X,Y,Z>)
+           Just (Deriving _ ds@(_:_)) ->
+             [spanHSE (show "InstHeads")
+                      "InstHeads"
+                      (SrcSpan (srcSpanFilename start)
+                               (srcSpanStartLine start)
+                               (srcSpanStartColumn start)
+                               (srcSpanEndLine end)
+                               (srcSpanEndColumn end))
+             |Just (IHead (SrcSpanInfo start _) _ _) <- [listToMaybe ds]
+             ,Just (IHead (SrcSpanInfo end _) _ _) <- [listToMaybe (reverse ds)]]
+           _ -> []
+
+-----------------------------------------------------------------------------------------
+-- | Generate a span from a HSE SrcSpan.
+spanHSE :: String -> String -> SrcSpan -> String
+spanHSE typ cons SrcSpan{..} = "[" ++ spanContent ++ "]"
+  where unqualify   = dropUntilLast '.'
+        spanContent =
+          unwords [unqualify typ
+                  ,cons
+                  ,show srcSpanStartLine
+                  ,show srcSpanStartColumn
+                  ,show srcSpanEndLine
+                  ,show srcSpanEndColumn]
+
+------------------------------------------------------------------------------
+-- | Like 'dropWhile', but repeats until the last match.
+dropUntilLast :: Char -> String -> String
+dropUntilLast ch = go []
+  where
+    go _ (c:cs) | c == ch = go [] cs
+    go acc (c:cs)         = go (c:acc) cs
+    go acc []             = reverse acc
+
+------------------------------------------------------------------------------
+parseMode :: ParseMode
+parseMode =
+  defaultParseMode { extensions = allExtensions
+                   , fixities   = Nothing
+                   }
+ where allExtensions = filter isDisabledExtention knownExtensions
+       isDisabledExtention (DisableExtension _) = False
+       isDisabledExtention _                    = True
+
+------------------------------------------------------------------------------
+-- Parsers that HSE hackage doesn't have
+parseImport :: ParseMode -> String -> ParseResult (ImportDecl SrcSpanInfo)
+parseImport mode code =
+  case parseModuleWithMode mode code of
+    ParseOk (Module _ _ _ [i] _) -> return i
+    ParseOk _ -> ParseFailed noLoc "parseImport"
+    ParseFailed x y -> ParseFailed x y
+
+------------------------------------------------------------------------------
+parseModulePragma :: ParseMode -> String -> ParseResult (ModulePragma SrcSpanInfo)
+parseModulePragma mode code =
+  case parseModuleWithMode mode (code ++ "\nmodule X where") of
+    ParseOk (Module _ _ [p] _ _) -> return p
+    ParseOk _ -> ParseFailed noLoc "parseModulePragma"
+    ParseFailed x y -> ParseFailed x y
+
+------------------------------------------------------------------------------
+genHSE :: Data a => a -> [String]
+genHSE x =
+  case gmapQ D x of
+    zs@(D y:ys) ->
+      case cast y of
+        Just s ->
+          spanHSE (show (show (typeOf x)))
+                  (showConstr (toConstr x))
+                  (srcInfoSpan s) :
+          concatMap (\(i,D d) -> pre x i ++ genHSE d)
+                    (zip [0..] ys)
+        _ ->
+          concatMap (\(D d) -> genHSE d) zs
+    _ -> []