kythe/

Binary helloworld is a test binary for running on GCP.

Binary rest_auth_check checks whether or not you can access a project via cloud build REST API: https://cloud.google.com/cloud-build/docs/api/reference/rest/ Usage: go build rest_auth_check ./rest_auth_check -project_id=some-project-id For authentication steps, see kythe/extractors/gcp/README.md

Binary extract extracts a pre-configured OpenJDK11 source tree to produce Kythe compilation units.

Binary java_wrapper wraps the real java command to invoke the standalone java extractor in parallel with the genuine compilation command.

Package bazel implements the internal plumbing of a configurable Bazel compilation unit extractor.

Package extutil implements shared code for extracting and writing output from Bazel actions to .kzip files.

bazel_go_extractor is a Bazel extra action that extracts Go compilations.

Program extract_kzip implements a Bazel extra action that captures a Kythe compilation record for a "spawn" action.

Binary gotool extracts Kythe compilation information for Go packages named by import path on the command line.

Package config defines configuration settings for extracting compilation records from a repository using a non-bazel build system.

Package base and its subpackages define default config data for different builders (cmake, gradle, maven).

Package gradle defines a default kythe.proto.ExtractionConfiguration for Java using Gradle.

Package mvn defines a default kythe.proto.ExtractionConfiguration for Java using Maven.

Binary preprocessor can modify a repo's build configuration file with the necessary bits to run Kythe extraction.

Package modifier provides a library for adding a forked javac executable into a build.gradle file or pom.xml file.

Binary runextractor provides a tool to wrap a repo's compilation with Kythe's custom extractor logic.

Package backup is a simple library for backing up a config file and restoring it using a temporary file.

Package cmakecmd extracts from a CMake-based repository.

Package compdb contains functionality necessary for extracting from a compile_commands.json file.

Package compdbcmd extracts from a compile_commands.json file.

Package gradlecmd extracts a gradle repo.

Package mavencmd extracts a maven repo.

Package smoke is a basic harness for testing the validity of config.ExtractRepo output.

Package constants defines relevant constants common to multiple extractors.

Package config contains logic for converting kythe.proto.extraction.RepoConfig to cloudbuild.yaml format as specified by https://cloud.google.com/cloud-build/docs/build-config.

Binary yamlgen generates a Cloud Build yaml config file for extracting a repo using Kythe.

Package golang produces Kythe compilation units for each Go import path specified.

Package govname supports the creation of VName protobuf messages for Go packages and other entities.

Program extract_proto_kzip implements a Bazel extra action that captures a Kythe compilation record for a protobuf "spawn" action.

Package validation contains logic for verifing the contents of a kzip.

Package indexer implements a Kythe indexer for the Go language.

Program go_example runs the Kythe Go indexer on a single package consisting of files named on the command line, for use in verifying schema examples.

Program go_indexer implements a Kythe indexer for the Go language.

Package languageserver provides an implementation of the Language Server Protocol v3.0 (https://github.com/Microsoft/language-server-protocol) This server implements the following capabilities: textDocumentSync (full) referenceProvider

Binary kythe_languageserver provides a Language Server Protocol v3 implementation for Kythe indexes that communicates via JSONRPC2.0 over stdio

Package pathmap provides utilities for matching and generating paths based on a pattern string.

Package analysis defines interfaces used to locate and analyze compilation units and their inputs.

Package driver contains a Driver implementation that sends analyses to a CompilationAnalyzer based on a Queue of compilations.

Package local implements CompilationAnalyzer utilities for local analyses.

Package proxy implements a wrapper that proxies an analysis request to a Kythe indexer that does not speak protocol buffers or RPCs.

Package cache implements a simple in-memory file cache and provides a simple Fetcher wrapper that uses the cache for its Fetch operations.

Package delimited implements a reader and writer for simple streams of length-delimited byte records.

Package dedup implements a duplication-reducing reader for streams of length-delimited byte records.

Package kcd defines an interface and utility functions for the implementation of a Kythe compilation database.

Package kythe implements the kcd.Unit interface for Kythe compilations.

Package kzipdb implements kcd.Reader using a kzip file as its backing store.

Package locked implements a delegating wrapper that protects each method of the resulting kcd.Reader or kcd.ReadWriter with a mutex, so that the result is safe for concurrent use by multiple goroutines.

Package memdb implements kcd.ReadWriter with an in-memory representation, suitable for testing or ephemeral service-based collections.

Package testutil provides support functions for unit testing implementations of the kcd.ReadWriter interface.

Package kindex implements an interface to compilation index files which are standalone CompilationUnits with all of their required inputs.

Package kzip implements the kzip compilation storage file format.

Package info provides utilities for summarizing the contents of a kzip.

Binary dedup_stream reads a delimited stream from stdin and writes a delimited stream to stdout.

Binary entrystream provides tools to manipulate a stream of delimited Entry messages.

Binary extractrepo provides a tool to run a Kythe extraction on a specified repository.

Binary repotester tests the high level validity of repo extraction.

Binary ktags emits ctags-formatted lines for the definitions in the given files.

Binary kzip provides tools to work with kzip archives.

Package createcmd provides the kzip command for creating simple kzip archives.

Package filtercmd provides the kzip command for filtering archives.

Package flags provides type EncodingFlag for use as a flag to specify Encoding.

Package infocmd provides the kzip command for obtaining info about a kzip archive.

Package mergecmd provides the kzip command for merging archives.

Package viewcmd displays the contents of compilation units stored in .kzip files.

Binary kzip_validator checks the contents of a kzip against a code repo and compares file coverage.

Binary shasum_tool calcuates the sha256 sum of the specified file.

Binary viewindex prints a .kindex/.kzip as JSON to stdout.

Package vfs defines a generic file system interface commonly used by Kythe libraries.

Package zip defines a VFS implementation that understands a zip archive as an isolated, read-only file system.

Package cli exposes a CLI interface to the Kythe services.

Package explore defines the ExploreService interface.

Package filetree defines the filetree Service interface and a simple in-memory implementation.

Package graph defines the graph Service interface and some useful utility functions.

Package graphstore defines the Service and Sharded interfaces, and provides some useful utility functions.

Package proxy defines a proxy graphstore.Service that delegates requests to other service implementations.

Package link implements the link resolver service.

Package web defines utility functions for exposing services over HTTP.

Package xrefs defines the xrefs Service interface and some useful utility functions.

Package api provides a union of the filetree, xrefs, and graph interfaces and a command-line flag parser.

Package explore provides a high-performance table-based implementation of the ExploreService defined in kythe/proto/explore.proto.

Package filetree implements a lookup table for files in a tree structure.

Package graph provides a high-performance table-based implementation of the graph.Service.

Package columnar implements the columnar table format for a Kythe xrefs service.

Package identifiers provides a high-performance table-based implementation of the identifiers.Service.

Package pipeline implements an in-process pipeline to create a combined filetree and xrefs serving table from a stream of GraphStore-ordered entries.

Package beamio provides Beam transformations for common IO patterns.

Package beamtest contains utilities to test Apache Beam pipelines.

Package nodes provides Beam transformations over *scpb.Nodes.

Binary http_server exposes HTTP interfaces for the xrefs and filetree services backed by a combined serving table.

Binary kwazthis (K, what's this?) determines what references are located at a particular offset (or line and column) within a file.

Binary kythe exposes a CLI interface to the xrefs and filetree services backed by a combined serving table.

Binary KytheFS exposes file content stored in Kythe as a virtual filesystem.

Binary write_tables creates a combined xrefs/filetree/search serving table based on a given GraphStore.

Package xrefs provides a high-performance table-based implementation of the xrefs.Service.

Package assemble provides functions to build the various components (nodes, edges, and decorations) of an xrefs serving table.

Package columnar implements the columnar table format for a Kythe xrefs service.

Package entryset implements a compact representation for sets of Kythe entry messages in the format emitted by indexers.

Package gsutil is collection of helper functions for storage tools.

Package inmemory provides a in-memory implementation of graphstore.Service and keyvalue.DB.

Package keyvalue implements a generic GraphStore for anything that implements the DB interface.

Package leveldb implements a graphstore.Service using a LevelDB backend database.

Package stream provides utility functions to consume Entry streams.

Package table implements lookup table interfaces for protobufs.

Binary directory_indexer produces a set of Entry protos representing the files in the given directories.

Binary read_entries scans the entries from a specified GraphStore and emits them to stdout as a delimited stream.

Binary triples implements a converter from an Entry stream to a stream of triples.

Binary write_entries reads a stream of protobuf entries on os.Stdin and writes each to a graphstore server.

Package graphstore contains common utilities for testing GraphStore implementations.

Package xrefs provides test utilities for the xrefs.Service.

Package keyvalue contains utilities to test keyvalue DB implementations.

Package testutil contains common utilities to test Kythe libraries.

Binary http_server exposes an HTTP interface for testing the xrefs and filetree services backed by a combined serving table.

Each non-flag argument is a file ticket that will be used in a DecorationsRequest to the --api service.

Package archive provides support for reading the contents of archives such as .zip and .tar files.

Package build provides information about how a given binary was built and in what context.

Package cmdutil exports shared logic for implementing command-line subcommands using the github.com/google/subcommands package.

Package compare implements comparisons between Kythe values.

Package datasize implements a type representing data sizes in bytes.

Package dedup implements a utility to determine if a record has not been seen before (whether it's unique).

Package disksort implements sorting algorithms for sets of data too large to fit fully in-memory.

Package rdf implements encoding of RDF triples, as described in http://www.w3.org/TR/2014/REC-n-triples-20140225/.

Package text contains utilities dealing with the encoding of source text.

Package flagutil is a collection of helper functions for Kythe binaries using the flag package.

Binary formatjson reads json from stdin and writes formatted json to stdout.

Package html is a set of utilities for manipulating html Nodes.

Package httpencoding provides functions to transparently encode/decode HTTP bodies

Package keys implements orderedcode encodings for Kythe types.

Package kytheuri provides a type to represent Kythe URIs.

Package markedsource defines functions for rendering MarkedSource.

Package metadata provides support code for processing Kythe metadata records, of the type generated by instrumented code generators for cross-language linkage.

Package netutil provides network utility functions.

Package pager implements a generic SetPager that splits a stream of Groups into a single Set and one-or-more associated Pages.

Package process contains an implementation of a callback-based asynchronous process.

Package profile provides a simple method for exposing profile information through a --cpu_profile flag.

Package ptypes is a thin wrapper around the golang.org/protobuf/ptypes package that adds support for Kythe message types, and handles some type format conversions.

Package reduce provides a simple interface for transforming a stream of inputs.

Package riegeli implements a Reader and Writer for the Riegeli records format.

Package schema defines constants used in the Kythe schema.

Package edges defines constants for Kythe edges.

Package facts defines constants for Kythe facts.

Program mkdata parses the kythe.proto.schema.Metadata from the Kythe schema.proto file descriptor into a Go/Java source file that can be compiled into the schema util package.

Package nodes defines constants for Kythe nodes.

Package tickets defines functions for manipulating Kythe tickets.

Package sortutil implements utilities for sorting.

Package span implements utilities to resolve byte offsets within a file to line and column numbers.

Binary extract_schema extracts a machine-readable representation of the Kythe schema from the schema documentation.

Binary print_extra_action takes a single argument that is a path to file with an protobuf wire-encoding of a Bazel ExtraActionInfo and prints it as JSON to stdout.

Binary print_test_status takes a single argument that is a path to file with an protobuf wire-encoding of a Bazel TestResultData and prints it as JSON to stdout.

Binary scan_leveldb is the cat command for LevelDB.

Binary write_extra_action reads a textproto ExtraActionInfo, wire-encodes it, and writes it to another file.

Package vnameutil provides utilities for generating consistent VNames from common path-like values (e.g., filenames, import paths).

Program test_vname_rules verifies that a set of vname mapping rules behave as expected.

Package server exposes an HTTP interface to the xrefs and filetree services.