Getting Started


## What EkLine can do

- **Check style automatically**: Keep your docs consistent with instant feedback.
- **Get smart suggestions**: Improve clarity, grammar, and structure with AI help.
- **See your quality score**: Measure and improve your docs over time.
- **Connect your tools**: Works with GitHub, VS Code, Google Docs, and more.
- **Catch problems early**: Find broken links and outdated terms before publishing.

## How to set up EkLine

- **Create your account**  
    Sign up at [EkLine](https://ekline.io) or log in to your workspace.

- **Pick how to use EkLine**  
    Choose the integration that fits your workflow:

    **GitHub/GitLab integration**: review docs in pull requests with automatic checks.

    **VS Code extension**: get suggestions as you write in your editor.

    **Google Docs extension**: edit and review directly inside Google Docs.

- **Add your first project**  
    Import your docs or connect your repo. EkLine supports Markdown, reStructuredText, AsciiDoc, and DITA (Darwin Information Typing Architecture).

## Make it your own

You can customize EkLine to fit your team. Set up:

- Rules from your company style guide.
- Your own terms and dictionaries.
- Fix levels, for example, warnings or errors.
- Workflows for different team roles.

## Need help

Email us at [support@EkLine.io](mailto:support@ekline.io). We’re here for you.

Welcome to EkLine! It’s a simple way to manage your technical documentation. Whether you're updating a feature guide, editing release notes, or checking docs for style issues, EkLine makes the process easier.

Overview

Integrations


## Prerequisites

Before you begin, ensure you have the following:

- An EkLine integration token. You can obtain this by visiting the [EkLine dashboard](https://ekline.io/dashboard) and clicking on the **View Integration Token** button.

## Create a new GitHub Actions workflow

In your GitHub repository, navigate to the "Actions" tab. Click "New workflow" and choose the "set up a workflow yourself" option.

In the new workflow file, you can name it **`ekline.yml`**. GitHub stores this file in the **`.github/workflows/`** directory in your repository.

## Configure the EkLine GitHub action

Copy and paste the following template into your workflow file:

```yaml
name: EkLine
on:
  push:
    branches:
      - master
      - main
  pull_request:
jobs:
  test-pr-review:
    if: github.event_name == 'pull_request'
    name: runner / EkLine Reviewer (github-pr-review)
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - uses: actions/checkout@v3
      - uses: ekline-io/ekline-github-action@v6
        with:
          content_dir: ./src/docs
          ek_token: ${{ secrets.ek_token }}
          github_token: ${{ secrets.github_token }}
          reporter: github-pr-review
          filter_mode: added
          # ignore_rule: "EK00001,EK00004" # Optional
          # exclude-directories: "node_modules,tests" # Optional
          # exclude-files: "README.md,CONTRIBUTING.md" # Optional
          # style-guide: "./.ekline-style-guide.yml" # Optional
```

### Configuration options

Below are all available configuration options for the EkLine GitHub Action:

| Option                | Description                                                                                      | Format or Allowed Values                                 | Default                |
|-----------------------|--------------------------------------------------------------------------------------------------|-------------------------------------------------------|------------------------|
| `content_dir`         | The content directory relative to the root directory.                                            | String, which is a relative path.                                | `.`                    |
| `ek_token`            | The EkLine integration token.                                    | String                                       | —                      |
| `github_token`        | The GITHUB_TOKEN, allows commenting and status updates.                                          | String, secret or `${{ secrets.github_token }}`      | `${{ secrets.github_token }}` |
| `reporter`            | How EkLine reports results. [github-pr-check, github-check, github-pr-review]                    | String                                               | `github-pr-check`      |
| `filter_mode`         | Filtering mode for results. [added, diff_context, file, no_filter]                                | String                                               | `added`                |
| `ignore_rule`         | Comma-separated list of rule identifiers to ignore.                                              | String, for example, "EK00001,EK00004"                   | —                      |
| `exclude-directories` | Comma-separated list of directories relative to `content_dir` to exclude from review. | String for example, "node_modules,tests" | — |
| `exclude-files`       | Comma-separated list of files relative to `content_dir` to exclude from review.                | String, for example, "README.md, CONTRIBUTING.md"         | —                      |
| `style-guide`         | Path to a custom style guide file, relative to repository root or `content_dir`.                | String, for example, `"./.ekline-style-guide.yml"`          | —                      |

### Filter modes

You can control how the EkLine reviewer filters results by specifying the **`filter_mode`** option. Available filter modes are as below:

- **added** default: Filter results by added or modified lines.
- **`diff_context`**: Filter results by diff context. For example, changed lines plus or minus N lines, where N could be 3.
- **`file`**: Filter results by added or modified file. EkLine reviewer reports results as long as they're in an added or modified file, even if the results aren't in the actual diff.
- **`nofilter`**: Don't filter any results. Useful for posting results as comments as much as possible and checking other results in the console simultaneously.

### Reporter types

- **`github-pr-check`**: Reports results to GitHub Checks.
- **`github-check`**: Similar to **`github-pr-check`**, but works for both pull requests and commits.
- **`github-pr-review`**: Reports results to GitHub PullRequest review comments using a GitHub Personal API Access Token.

### Ignoring specific rules

To ignore specific rules during the review process, you can use the `ignore_rule` flag. This flag accepts a comma-separated list of rule identifiers that you wish to skip.

For example, if you want to ignore rules `EK00001` and `EK00004`, you can set the `ignore_rule` flag in your configuration like this:

```
ignore_rule: "EK00001,EK00004"
```

## Save and commit the workflow file

After configuring the workflow file, click "Start commit" to save and commit the file to your repository. The EkLine GitHub Action runs automatically when you push changes to the **`master`** or **`main`** branches or create a pull request.

## Add the EkLine integration token to your repository secrets


<img
    className={'rounded-2xl'}
    width={1880}
    height={1044}
    src={`/assets/images/docs/secrets.png`}
    alt={`Update Secrets`}
/>

## Grant write permissions to workflows

To enable the EkLine GitHub Action to add comments to pull requests, you must grant write permissions to workflows. There are two ways to achieve this:

### Option 1: Through repository settings

1. Navigate to **Settings > Code and Automation > Actions > General > Workflow permissions**.
2. Click the drop-down menu and select **Read and write permissions**.
3. Click **Save** to apply the changes.

<img
    className={'rounded-2xl'}
    width={1880}
    height={1044}
    src={`/assets/images/docs/workflow.png`}
    alt={`Grant write permissions to workflows`}
/>

### Option 2: Through the workflow file

Add the following permissions block to your workflow file:

```yaml
permissions:
  contents: read
  pull-requests: write
```

## Check the EkLine GitHub Action results

Once the EkLine GitHub Action runs, you can view the results in the "Actions" tab of your repository.

Now, you have integrated the EkLine GitHub Action into your repository for automated documentation review. Enjoy better quality and consistency in your documentation.

## Other options

[EkLine GitHub Action on Label](/documentation/github-action-label)


This guide will walk you through using the EkLine GitHub Action for automated documentation review in your GitHub repositories.

EkLine GitHub Integration Guide


## Prerequisites

- A GitHub repository with EkLine set up.
- EkLine GitHub Action configured in your repository.

## Steps

1. Open the **`.github/workflows/ekline.yml`** file in your GitHub repository.
2. Change the **`on`** section of the GitHub action to trigger on **`pull_request`** with **`types: [labeled]`**:
```yaml
on:
  pull_request:
    types: [labeled]
```
3. Add a new **`if`** condition to the **`jobs`** section to check if the label "ekline" is present:
```
jobs:
  test-pr-review:
    if: contains(github.event.label.name, 'ekline')
```
4. Save the changes to **`ekline.yml`** file.
The updated **`ekline.yml`** appears like this:
```yaml
name: EkLine
on:
  pull_request:
    types: [labeled]

jobs:
  test-pr-review:
    if: contains(github.event.label.name, 'ekline')
    name: runner / EkLine Reviewer (github-pr-review)
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: ekline-io/ekline-github-action@v6
        with:
          content_dir: ./src/docs
          ek_token: ${{ secrets.ek_token }}
          github_token: ${{ secrets.github_token }}
          reporter: github-pr-review
          filter_mode: added
          # ignore_rule: "EK00001,EK00004" # Optional
```

With these changes, EkLine GitHub Action triggers when someone adds a label named "ekline" to a pull request.

## Usage

Add the "ekline" label to a specific pull request to run the EkLine GitHub Action. Upon adding the label, the action triggers and executes the configured checks.

This guide helps configure the EkLine GitHub Action to run when a specific label, named 'ekline', gets added to a pull request.

EkLine GitHub Action on Label


## Prerequisites

1. You have an EkLine integration token. You can obtain this by visiting the [EkLine dashboard](https://ekline.io/dashboard) and clicking on the **View Integration Token** button.
2. You have a GitLab account and a GitLab API token.


## Create `.gitlab-ci.yml` file

Create a new file named **`.gitlab-ci.yml`** in your project's root directory and add the following content:

```yaml
stages:
  - ekline-pr-review

ekline-pr-review-job:
  stage: ekline-pr-review
  image: ghcr.io/ekline-io/ekline-ci-cd:v6
  rules:
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
  script:
    - echo "Running EkLine"
  variables:
    INPUT_EK_TOKEN: $EK_TOKEN
    INPUT_GITLAB_TOKEN: $GITLAB_API_TOKEN
    INPUT_CONTENT_DIR: '<path_to_content_directory>'
    INPUT_REPORTER: 'gitlab-mr-discussion'
    INPUT_FILTER_MODE: 'added'
    # INPUT_IGNORE_RULE: "EK00001,EK00004" # Optional
    # INPUT_EXCLUDE_DIRECTORIES: "docs/archive,legacy_content" # Optional: Comma-separated list
    # INPUT_EXCLUDE_FILES: "README.md,CHANGELOG.md" # Optional: Comma-separated list
    # INPUT_STYLE_GUIDE: "https://example.com/my-style-guide.json" # Optional: URL or path
```

Replace **`<path_to_content_directory>`** with the actual path to your content directory.


## Configure GitLab API token

1. In GitLab, go to Settings > Access tokens.
2. Create a token with API access.
3. Add the token to your project's CI/CD > Variables as **`GITLAB_API_TOKEN`**.

## Configure EkLine integration token

1. Obtain your integration token by visiting the [EkLine dashboard](https://ekline.io/dashboard) and clicking on the **View Integration Token** button.
2. Add the token to your project's CI/CD > Variables as **`EK_TOKEN`**.

## Configure input reporter (optional)

You can choose between two options for **`INPUT_REPORTER`**:

- **`gitlab-mr-discussion`** (default): Reports results as merge request discussions.
- **`gitlab-mr-commit`**: Reports results to each commit in GitLab MergeRequest.

## Configure input filter mode (optional)

The following options are available for **`INPUT_FILTER_MODE`**:

- **added** default: Filter results by added or modified lines.
- **`diff_context`**: Filter results by diff context. That's changed lines +-N lines, such as N=3.
- **`file`**: Filter results by added or modified file. EkLine reports results as long as they are in added or modified files even if the results aren't in the actual diff.
- **`nofilter`**: Don't filter any results. Useful for posting results as comments as much as possible and check other results in the console at the same time.

## Ignoring specific optional rules

To ignore specific rules during the review process, you can use the `INPUT_IGNORE_RULE` flag. This flag accepts a comma-separated list of rule identifiers that you wish to skip.

For example, if you want to ignore rules `EK00001` and `EK00004`, you can set the `INPUT_IGNORE_RULE` flag in your configuration like this:

```
  INPUT_IGNORE_RULE: "EK00001,EK00004"
```

## Exclude specific content directories and files

- **Exclude specific directories** from review.
- **Exclude specific files** from review.
- **Specify a custom style guide** to apply during content analysis.

## Example usages

**Exclude directories and files, and specify a style guide:**
```yaml
variables:
  INPUT_CONTENT_DIR: 'docs'
  INPUT_EXCLUDE_DIRECTORIES: "docs/archive,docs/drafts"
  INPUT_EXCLUDE_FILES: "README.md,docs/legacy.md"
  INPUT_STYLE_GUIDE: "https://example.com/custom-style-guide.json"
```

**Just exclude files:**
```yaml
variables:
  INPUT_EXCLUDE_FILES: "README.md,CONTRIBUTING.md"
```

**Specify a style guide only:**
```yaml
variables:
  INPUT_STYLE_GUIDE: ".ekline/style-guide.json"
```


Once you have configured the options, save your changes and push the **`.gitlab-ci.yml`** file to your repository. Now, EkLine runs on your content directory and gives feedback as merge request discussions tailored to your custom settings.


This guide will walk you through setting up the EkLine integration with GitLab.

EkLine GitLab Integration Guide


## Installation

Download the suitable EkLine binary for your operating system from this [link](https://github.com/ekline-io/ekline-cli-binaries/releases/latest).

## Usage

To use the EkLine CLI, execute the following command:

```bash
ekline-cli [options]
```

### Options

The following options can be used with the EkLine CLI:

- **v, --version**

Displays the current version of the EkLine CLI.

- **d, --debug**

Enables verbose logging to provide detailed debug information.

- **o, --output `<output-file-name>`**

Specifies the output filename. If not provided, the output is displayed in the terminal. For JSON output, use the file extension **`.jsonl`**. For CSV output, use the file extension **`.csv`**.

- **ns, --no-suggestion**

Disables suggestions. Please note that suggestions are only generated for **`.jsonl`** or **`.csv`** output formats.

- **i, --ignore `<rules>`**

Ignore specified rules during the check. Pass the rules as comma-separated values. For example, **`EK1,EK4`**.

- **cd, --content-directory `<contentDirectory...>`**

Specifies the directory paths where the content files are located. Paths should be relative to the current directory.

- **et, --ek-token `<token>`**

Authenticates with your EkLine integration token. This option is mandatory.

- **--exclude-directories `<paths>`**

Specifies directory paths to exclude. Paths should be relative to the current directory.

- **--exclude-files `<paths>`**

Specifies file paths to exclude. For example, `temp.md,draft.md`.

- **--style-guide `Microsoft`**

Specifies the style guide to use. The available options are `Microsoft`, `Google`, and `Marketing`.

- **--openapi-spec `<path>`**

Specifies the path to an OpenAPI specification file.

- **h, --help**

Displays the command's help information.


## Obtaining your EkLine integration token

You can obtain your EkLine integration token by visiting the [EkLine dashboard](https://ekline.io/dashboard) and clicking on the **View Integration Token** button.

## Examples

Below are a few examples of using the EkLine CLI:

1. **Running EkLine CLI and ignoring specific rules**

```bash
ekline-cli -i EK1,EK4 --ek-token YOUR_EKLINE_TOKEN
```

2. **Running EkLine CLI and specifying a content directory**

```bash
ekline-cli -cd ./content --ek-token YOUR_EKLINE_TOKEN
```

Make sure to replace **`YOUR_EKLINE_TOKEN`** in these examples with your actual EkLine integration token.


The EkLine CLI streamlines document quality control. This guide explains the available options and provides examples for effectively using the EkLine CLI.

EkLine CLI Documentation


## Prerequisites

You have an EkLine integration token. You can obtain this by visiting the [EkLine dashboard](https://ekline.io/dashboard) and clicking on the **View Integration Token** button.

## Getting started

### Installation

To install the VSCode extension from the web, follow these steps:

1. Visit the [EkLine Extension Page](https://marketplace.visualstudio.com/items?itemName=EkLine.ekline-vscode) on VSCode Marketplace.
2. Click Install.
3. Open Visual Studio Code when prompted.

Alternately, to install the VSCode extension from within VSCode:

1. Open Visual Studio Code.
2. Click on the Extensions icon in the Activity Bar on the side of the window to access the Extensions view.
3. Type "EkLine" in the Extensions view search box.
4. Click the "Install" button next to the extension with the same name.

### Configure EkLine linter

When you first install the VSCode extension, it invites you to activate with EkLine.
Before using the extension, you need to set the EkLine token, which you can obtain by visiting the [EkLine dashboard](https://ekline.io/dashboard) and clicking on the **View Integration Token** button.

If you cancel or input an invalid token, the extension displays a popup offering another chance to set up EkLine or turn off for avoiding future popups.
Once turned off, execute 'Configure EkLine Linter' from the Command Palette or clear the 'off' box in Extension Settings.

## Usage

The extension runs EkLine on supported files when opened or saved.

To analyze all supported files in the workspace, execute 'Run EkLine Linter' from the Command Palette.


EkLine flags any style guide violations in your company's documentation with Visual Studio Code diagnostics. It offers immediate feedback, facilitating consistency in your documentation.

EkLine VSCode Integration


## Prerequisites

1. You have an EkLine integration token. You can obtain this by visiting the [EkLine dashboard](https://ekline.io/dashboard) and clicking on the **View Integration Token** button.
2. You have a Bitbucket account and the necessary permissions to configure pipelines.

## Create `bitbucket-pipelines.yml` file

Create a new file named **`bitbucket-pipelines.yml`** in your project's root directory and add the following content:

```yaml
runEkLineStep: &runEkLineStep
  name: EkLine Documentation Review
  image:
    name: ghcr.io/ekline-io/ekline-ci-cd:v6.8
  script:
    - export EK_TOKEN=$EK_TOKEN
    - export INPUT_CONTENT_DIR='<path_to_content_directory>'
    # Uncomment and configure the following lines to use additional options:
    # - export INPUT_EXCLUDE_DIRECTORIES='<dir1>,<dir2>'
    # - export INPUT_EXCLUDE_FILES='<file1.md>,<file2.txt>'
    # - export INPUT_STYLE_GUIDE='GOOGLE'
    - /entrypoint.sh

pipelines:
  branches:
    main:
      - step: *runEkLineStep

  pull-requests:
    '**':
      - step: *runEkLineStep
```

Replace **`<path_to_content_directory>`** with the actual path to your content directory.

## Configure Bitbucket environment variables

1. In Bitbucket, navigate to your repository settings.
2. Go to **Repository settings > Pipelines > Repository variables**.
3. Add the following variables:
    **`EK_TOKEN`**: Your EkLine integration token.

## Configure input options

### Ignoring specific rules (Optional)

To ignore specific rules during the review process, you can use the `INPUT_IGNORE_RULE` flag. This flag accepts a comma-separated list of rule identifiers that you wish to skip.

For example, if you want to ignore rules `EK00001` and `EK00004`, you can set the `INPUT_IGNORE_RULE` flag in your configuration like this:

```yaml
  INPUT_IGNORE_RULE: "EK00001,EK00004"
```


This guide will walk you through setting up the EkLine integration with Bitbucket.

EkLine Bitbucket Integration Guide

"use strict";
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
function _createMdxContent(props) {
  const _components = {
    a: "a",
    h2: "h2",
    h3: "h3",
    li: "li",
    ol: "ol",
    p: "p",
    span: "span",
    strong: "strong",
    ...props.components
  };
  return _jsxs(_Fragment, {
    children: [_jsxs(_components.h2, {
      id: "prerequisites",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        href: "#prerequisites",
        children: _jsx(_components.span, {
          className: "icon icon-link"
        })
      }), "Prerequisites"]
    }), "\n", _jsxs(_components.p, {
      children: ["You have an EkLine integration token. You can obtain this by visiting the ", _jsx(_components.a, {
        href: "https://ekline.io/dashboard",
        children: "EkLine dashboard"
      }), " and clicking on the ", _jsx(_components.strong, {
        children: "View Integration Token"
      }), " button."]
    }), "\n", _jsxs(_components.h2, {
      id: "getting-started",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        href: "#getting-started",
        children: _jsx(_components.span, {
          className: "icon icon-link"
        })
      }), "Getting started"]
    }), "\n", _jsxs(_components.h3, {
      id: "installation",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        href: "#installation",
        children: _jsx(_components.span, {
          className: "icon icon-link"
        })
      }), "Installation"]
    }), "\n", _jsx(_components.p, {
      children: "To install the VSCode extension from the web, follow these steps:"
    }), "\n", _jsxs(_components.ol, {
      children: ["\n", _jsxs(_components.li, {
        children: ["Visit the ", _jsx(_components.a, {
          href: "https://marketplace.visualstudio.com/items?itemName=EkLine.ekline-vscode",
          children: "EkLine Extension Page"
        }), " on VSCode Marketplace."]
      }), "\n", _jsx(_components.li, {
        children: "Click Install."
      }), "\n", _jsx(_components.li, {
        children: "Open Visual Studio Code when prompted."
      }), "\n"]
    }), "\n", _jsx(_components.p, {
      children: "Alternately, to install the VSCode extension from within VSCode:"
    }), "\n", _jsxs(_components.ol, {
      children: ["\n", _jsx(_components.li, {
        children: "Open Visual Studio Code."
      }), "\n", _jsx(_components.li, {
        children: "Click on the Extensions icon in the Activity Bar on the side of the window to access the Extensions view."
      }), "\n", _jsx(_components.li, {
        children: "Type \"EkLine\" in the Extensions view search box."
      }), "\n", _jsx(_components.li, {
        children: "Click the \"Install\" button next to the extension with the same name."
      }), "\n"]
    }), "\n", _jsxs(_components.h3, {
      id: "configure-ekline-linter",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        href: "#configure-ekline-linter",
        children: _jsx(_components.span, {
          className: "icon icon-link"
        })
      }), "Configure EkLine linter"]
    }), "\n", _jsxs(_components.p, {
      children: ["When you first install the VSCode extension, it invites you to activate with EkLine.\nBefore using the extension, you need to set the EkLine token, which you can obtain by visiting the ", _jsx(_components.a, {
        href: "https://ekline.io/dashboard",
        children: "EkLine dashboard"
      }), " and clicking on the ", _jsx(_components.strong, {
        children: "View Integration Token"
      }), " button."]
    }), "\n", _jsx(_components.p, {
      children: "If you cancel or input an invalid token, the extension displays a popup offering another chance to set up EkLine or turn off for avoiding future popups.\nOnce turned off, execute 'Configure EkLine Linter' from the Command Palette or clear the 'off' box in Extension Settings."
    }), "\n", _jsxs(_components.h2, {
      id: "usage",
      children: [_jsx(_components.a, {
        "aria-hidden": "true",
        tabIndex: "-1",
        href: "#usage",
        children: _jsx(_components.span, {
          className: "icon icon-link"
        })
      }), "Usage"]
    }), "\n", _jsx(_components.p, {
      children: "The extension runs EkLine on supported files when opened or saved."
    }), "\n", _jsx(_components.p, {
      children: "To analyze all supported files in the workspace, execute 'Run EkLine Linter' from the Command Palette."
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = props.components || ({});
  return MDXLayout ? _jsx(MDXLayout, {
    ...props,
    children: _jsx(_createMdxContent, {
      ...props
    })
  }) : _createMdxContent(props);
}
return {
  default: MDXContent
};


Getting Started

Integrations

VSCode Integration

EkLine flags any style guide violations in your company's documentation with Visual Studio Code diagnostics. It offers immediate feedback, facilitating consistency in your documentation.

Prerequisites

Getting started

Installation

Configure EkLine linter

Usage

Table of Contents