@neocode-ai/web 1.1.1

package/src/content/docs/github.mdx

@@ -0,0 +1,321 @@
+---
+title: GitHub
+description: Use NeoCode in GitHub issues and pull-requests.
+---
+
+NeoCode integrates with your GitHub workflow. Mention `/neocode` or `/oc` in your comment, and NeoCode will execute tasks within your GitHub Actions runner.
+
+---
+
+## Features
+
+- **Triage issues**: Ask NeoCode to look into an issue and explain it to you.
+- **Fix and implement**: Ask NeoCode to fix an issue or implement a feature. And it will work in a new branch and submits a PR with all the changes.
+- **Secure**: NeoCode runs inside your GitHub's runners.
+
+---
+
+## Installation
+
+Run the following command in a project that is in a GitHub repo:
+
+```bash
+neocode github install
+```
+
+This will walk you through installing the GitHub app, creating the workflow, and setting up secrets.
+
+---
+
+### Manual Setup
+
+Or you can set it up manually.
+
+1. **Install the GitHub app**
+
+   Head over to [**github.com/apps/neocode-agent**](https://github.com/apps/neocode-agent). Make sure it's installed on the target repository.
+
+2. **Add the workflow**
+
+   Add the following workflow file to `.github/workflows/neocode.yml` in your repo. Make sure to set the appropriate `model` and required API keys in `env`.
+
+   ```yml title=".github/workflows/neocode.yml" {24,26}
+   name: neocode
+
+   on:
+     issue_comment:
+       types: [created]
+     pull_request_review_comment:
+       types: [created]
+
+   jobs:
+     neocode:
+       if: |
+         contains(github.event.comment.body, '/oc') ||
+         contains(github.event.comment.body, '/neocode')
+       runs-on: ubuntu-latest
+       permissions:
+         id-token: write
+       steps:
+          - name: Checkout repository
+            uses: actions/checkout@v6
+            with:
+              fetch-depth: 1
+              persist-credentials: false
+
+          - name: Run NeoCode
+           uses: neopilot-ai/neocode/github@latest
+           env:
+             ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+           with:
+             model: anthropic/claude-sonnet-4-20250514
+             # share: true
+             # github_token: xxxx
+   ```
+
+3. **Store the API keys in secrets**
+
+   In your organization or project **settings**, expand **Secrets and variables** on the left and select **Actions**. And add the required API keys.
+
+---
+
+## Configuration
+
+- `model`: The model to use with NeoCode. Takes the format of `provider/model`. This is **required**.
+- `agent`: The agent to use. Must be a primary agent. Falls back to `default_agent` from config or `"build"` if not found.
+- `share`: Whether to share the NeoCode session. Defaults to **true** for public repositories.
+- `prompt`: Optional custom prompt to override the default behavior. Use this to customize how NeoCode processes requests.
+- `token`: Optional GitHub access token for performing operations such as creating comments, committing changes, and opening pull requests. By default, NeoCode uses the installation access token from the NeoCode GitHub App, so commits, comments, and pull requests appear as coming from the app.
+
+  Alternatively, you can use the GitHub Action runner's [built-in `GITHUB_TOKEN`](https://docs.github.com/en/actions/tutorials/authenticate-with-github_token) without installing the NeoCode GitHub App. Just make sure to grant the required permissions in your workflow:
+
+  ```yaml
+  permissions:
+    id-token: write
+    contents: write
+    pull-requests: write
+    issues: write
+  ```
+
+  You can also use a [personal access tokens](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens)(PAT) if preferred.
+
+---
+
+## Supported Events
+
+NeoCode can be triggered by the following GitHub events:
+
+| Event Type                    | Triggered By                           | Details                                                                                                         |
+| ----------------------------- | -------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| `issue_comment`               | Comment on an issue or PR              | Mention `/neocode` or `/oc` in your comment. NeoCode reads context and can create branches, open PRs, or reply. |
+| `pull_request_review_comment` | Comment on specific code lines in a PR | Mention `/neocode` or `/oc` while reviewing code. NeoCode receives file path, line numbers, and diff context.   |
+| `issues`                      | Issue opened or edited                 | Automatically trigger NeoCode when issues are created or modified. Requires `prompt` input.                     |
+| `pull_request`                | PR opened or updated                   | Automatically trigger NeoCode when PRs are opened, synchronized, or reopened. Useful for automated reviews.     |
+| `schedule`                    | Cron-based schedule                    | Run NeoCode on a schedule. Requires `prompt` input. Output goes to logs and PRs (no issue to comment on).       |
+| `workflow_dispatch`           | Manual trigger from GitHub UI          | Trigger NeoCode on demand via Actions tab. Requires `prompt` input. Output goes to logs and PRs.                |
+
+### Schedule Example
+
+Run NeoCode on a schedule to perform automated tasks:
+
+```yaml title=".github/workflows/neocode-scheduled.yml"
+name: Scheduled NeoCode Task
+
+on:
+  schedule:
+    - cron: "0 9 * * 1" # Every Monday at 9am UTC
+
+jobs:
+  neocode:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: write
+      pull-requests: write
+      issues: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - name: Run NeoCode
+        uses: neopilot-ai/neocode/github@latest
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+        with:
+          model: anthropic/claude-sonnet-4-20250514
+          prompt: |
+            Review the codebase for any TODO comments and create a summary.
+            If you find issues worth addressing, open an issue to track them.
+```
+
+For scheduled events, the `prompt` input is **required** since there's no comment to extract instructions from. Scheduled workflows run without a user context to permission-check, so the workflow must grant `contents: write` and `pull-requests: write` if you expect NeoCode to create branches or PRs.
+
+---
+
+### Pull Request Example
+
+Automatically review PRs when they are opened or updated:
+
+```yaml title=".github/workflows/neocode-review.yml"
+name: neocode-review
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+
+jobs:
+  review:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+      pull-requests: read
+      issues: read
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - uses: neopilot-ai/neocode/github@latest
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          model: anthropic/claude-sonnet-4-20250514
+          use_github_token: true
+          prompt: |
+            Review this pull request:
+            - Check for code quality issues
+            - Look for potential bugs
+            - Suggest improvements
+```
+
+For `pull_request` events, if no `prompt` is provided, NeoCode defaults to reviewing the pull request.
+
+---
+
+### Issues Triage Example
+
+Automatically triage new issues. This example filters to accounts older than 30 days to reduce spam:
+
+```yaml title=".github/workflows/neocode-triage.yml"
+name: Issue Triage
+
+on:
+  issues:
+    types: [opened]
+
+jobs:
+  triage:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: write
+      pull-requests: write
+      issues: write
+    steps:
+      - name: Check account age
+        id: check
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const user = await github.rest.users.getByUsername({
+              username: context.payload.issue.user.login
+            });
+            const created = new Date(user.data.created_at);
+            const days = (Date.now() - created) / (1000 * 60 * 60 * 24);
+            return days >= 30;
+          result-encoding: string
+
+      - uses: actions/checkout@v6
+        if: steps.check.outputs.result == 'true'
+        with:
+          persist-credentials: false
+
+      - uses: neopilot-ai/neocode/github@latest
+        if: steps.check.outputs.result == 'true'
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+        with:
+          model: anthropic/claude-sonnet-4-20250514
+          prompt: |
+            Review this issue. If there's a clear fix or relevant docs:
+            - Provide documentation links
+            - Add error handling guidance for code examples
+            Otherwise, do not comment.
+```
+
+For `issues` events, the `prompt` input is **required** since there's no comment to extract instructions from.
+
+---
+
+## Custom prompts
+
+Override the default prompt to customize NeoCode's behavior for your workflow.
+
+```yaml title=".github/workflows/neocode.yml"
+- uses: neopilot-ai/neocode/github@latest
+  with:
+    model: anthropic/claude-sonnet-4-5
+    prompt: |
+      Review this pull request:
+      - Check for code quality issues
+      - Look for potential bugs
+      - Suggest improvements
+```
+
+This is useful for enforcing specific review criteria, coding standards, or focus areas relevant to your project.
+
+---
+
+## Examples
+
+Here are some examples of how you can use NeoCode in GitHub.
+
+- **Explain an issue**
+
+  Add this comment in a GitHub issue.
+
+  ```
+  /neocode explain this issue
+  ```
+
+  NeoCode will read the entire thread, including all comments, and reply with a clear explanation.
+
+- **Fix an issue**
+
+  In a GitHub issue, say:
+
+  ```
+  /neocode fix this
+  ```
+
+  And NeoCode will create a new branch, implement the changes, and open a PR with the changes.
+
+- **Review PRs and make changes**
+
+  Leave the following comment on a GitHub PR.
+
+  ```
+  Delete the attachment from S3 when the note is removed /oc
+  ```
+
+  NeoCode will implement the requested change and commit it to the same PR.
+
+- **Review specific code lines**
+
+  Leave a comment directly on code lines in the PR's "Files" tab. NeoCode automatically detects the file, line numbers, and diff context to provide precise responses.
+
+  ```
+  [Comment on specific lines in Files tab]
+  /oc add error handling here
+  ```
+
+  When commenting on specific lines, NeoCode receives:
+  - The exact file being reviewed
+  - The specific lines of code
+  - The surrounding diff context
+  - Line number information
+
+  This allows for more targeted requests without needing to specify file paths or line numbers manually.

package/src/content/docs/gitlab.mdx

@@ -0,0 +1,195 @@
+---
+title: GitLab
+description: Use NeoCode in GitLab issues and merge requests.
+---
+
+NeoCode integrates with your GitLab workflow through your GitLab CI/CD pipeline or with GitLab Duo.
+
+In both cases, NeoCode will run on your GitLab runners.
+
+---
+
+## GitLab CI
+
+NeoCode works in a regular GitLab pipeline. You can build it into a pipeline as a [CI component](https://docs.gitlab.com/ee/ci/components/)
+
+Here we are using a community-created CI/CD component for NeoCode — [nagyv/gitlab-neocode](https://gitlab.com/nagyv/gitlab-neocode).
+
+---
+
+### Features
+
+- **Use custom configuration per job**: Configure NeoCode with a custom configuration directory, for example `./config/#custom-directory` to enable or disable functionality per NeoCode invocation.
+- **Minimal setup**: The CI component sets up NeoCode in the background, you only need to create the NeoCode configuration and the initial prompt.
+- **Flexible**: The CI component supports several inputs for customizing its behavior
+
+---
+
+### Setup
+
+1. Store your NeoCode authentication JSON as a File type CI environment variables under **Settings** > **CI/CD** > **Variables**. Make sure to mark them as "Masked and hidden".
+2. Add the following to your `.gitlab-ci.yml` file.
+
+   ```yaml title=".gitlab-ci.yml"
+   include:
+     - component: $CI_SERVER_FQDN/nagyv/gitlab-neocode/neocode@2
+       inputs:
+         config_dir: ${CI_PROJECT_DIR}/neocode-config
+         auth_json: $NEOCODE_AUTH_JSON # The variable name for your NeoCode authentication JSON
+         command: optional-custom-command
+         message: "Your prompt here"
+   ```
+
+For more inputs and use cases [check out the docs](https://gitlab.com/explore/catalog/nagyv/gitlab-neocode) for this component.
+
+---
+
+## GitLab Duo
+
+NeoCode integrates with your GitLab workflow.
+Mention `@neocode` in a comment, and NeoCode will execute tasks within your GitLab CI pipeline.
+
+---
+
+### Features
+
+- **Triage issues**: Ask NeoCode to look into an issue and explain it to you.
+- **Fix and implement**: Ask NeoCode to fix an issue or implement a feature.
+  It will create a new branch and raise a merge request with the changes.
+- **Secure**: NeoCode runs on your GitLab runners.
+
+---
+
+### Setup
+
+NeoCode runs in your GitLab CI/CD pipeline, here's what you'll need to set it up:
+
+:::tip
+Check out the [**GitLab docs**](https://docs.gitlab.com/user/duo_agent_platform/agent_assistant/) for up to date instructions.
+:::
+
+1.  Configure your GitLab environment
+2.  Set up CI/CD
+3.  Get an AI model provider API key
+4.  Create a service account
+5.  Configure CI/CD variables
+6.  Create a flow config file, here's an example:
+
+        <details>
+
+    <summary>Flow configuration</summary>
+
+    ```yaml
+    image: node:22-slim
+    commands:
+      - echo "Installing neocode"
+      - npm install --global neocode-ai
+      - echo "Installing glab"
+      - export GITLAB_TOKEN=$GITLAB_TOKEN_NEOCODE
+      - apt-get update --quiet && apt-get install --yes curl wget gpg git && rm --recursive --force /var/lib/apt/lists/*
+      - curl --silent --show-error --location "https://raw.githubusercontent.com/upciti/wakemeops/main/assets/install_repository" | bash
+      - apt-get install --yes glab
+      - echo "Configuring glab"
+      - echo $GITLAB_HOST
+      - echo "Creating NeoCode auth configuration"
+      - mkdir --parents ~/.local/share/neocode
+      - |
+        cat > ~/.local/share/neocode/auth.json << EOF
+        {
+          "anthropic": {
+            "type": "api",
+            "key": "$ANTHROPIC_API_KEY"
+          }
+        }
+        EOF
+      - echo "Configuring git"
+      - git config --global user.email "neocode@gitlab.com"
+      - git config --global user.name "NeoCode"
+      - echo "Testing glab"
+      - glab issue list
+      - echo "Running NeoCode"
+      - |
+        neocode run "
+        You are an AI assistant helping with GitLab operations.
+
+        Context: $AI_FLOW_CONTEXT
+        Task: $AI_FLOW_INPUT
+        Event: $AI_FLOW_EVENT
+
+        Please execute the requested task using the available GitLab tools.
+        Be thorough in your analysis and provide clear explanations.
+
+        <important>
+        Please use the glab CLI to access data from GitLab. The glab CLI has already been authenticated. You can run the corresponding commands.
+
+        If you are asked to summarize an MR or issue or asked to provide more information then please post back a note to the MR/Issue so that the user can see it.
+        You don't need to commit or push up changes, those will be done automatically based on the file changes you make.
+        </important>
+        "
+      - git checkout --branch $CI_WORKLOAD_REF origin/$CI_WORKLOAD_REF
+      - echo "Checking for git changes and pushing if any exist"
+      - |
+        if ! git diff --quiet || ! git diff --cached --quiet || [ --not --zero "$(git ls-files --others --exclude-standard)" ]; then
+          echo "Git changes detected, adding and pushing..."
+          git add .
+          if git diff --cached --quiet; then
+            echo "No staged changes to commit"
+          else
+            echo "Committing changes to branch: $CI_WORKLOAD_REF"
+            git commit --message "Codex changes"
+            echo "Pushing changes up to $CI_WORKLOAD_REF"
+            git push https://gitlab-ci-token:$GITLAB_TOKEN@$GITLAB_HOST/gl-demo-ultimate-dev-ai-epic-17570/test-java-project.git $CI_WORKLOAD_REF
+            echo "Changes successfully pushed"
+          fi
+        else
+          echo "No git changes detected, skipping push"
+        fi
+    variables:
+      - ANTHROPIC_API_KEY
+      - GITLAB_TOKEN_NEOCODE
+      - GITLAB_HOST
+    ```
+
+        </details>
+
+You can refer to the [GitLab CLI agents docs](https://docs.gitlab.com/user/duo_agent_platform/agent_assistant/) for detailed instructions.
+
+---
+
+### Examples
+
+Here are some examples of how you can use NeoCode in GitLab.
+
+:::tip
+You can configure to use a different trigger phrase than `@neocode`.
+:::
+
+- **Explain an issue**
+
+  Add this comment in a GitLab issue.
+
+  ```
+  @neocode explain this issue
+  ```
+
+  NeoCode will read the issue and reply with a clear explanation.
+
+- **Fix an issue**
+
+  In a GitLab issue, say:
+
+  ```
+  @neocode fix this
+  ```
+
+  NeoCode will create a new branch, implement the changes, and open a merge request with the changes.
+
+- **Review merge requests**
+
+  Leave the following comment on a GitLab merge request.
+
+  ```
+  @neocode review this merge request
+  ```
+
+  NeoCode will review the merge request and provide feedback.

package/src/content/docs/ide.mdx

@@ -0,0 +1,48 @@
+---
+title: IDE
+description: The NeoCode extension for VS Code, Cursor, and other IDEs
+---
+
+NeoCode integrates with VS Code, Cursor, or any IDE that supports a terminal. Just run `neocode` in the terminal to get started.
+
+---
+
+## Usage
+
+- **Quick Launch**: Use `Cmd+Esc` (Mac) or `Ctrl+Esc` (Windows/Linux) to open NeoCode in a split terminal view, or focus an existing terminal session if one is already running.
+- **New Session**: Use `Cmd+Shift+Esc` (Mac) or `Ctrl+Shift+Esc` (Windows/Linux) to start a new NeoCode terminal session, even if one is already open. You can also click the NeoCode button in the UI.
+- **Context Awareness**: Automatically share your current selection or tab with NeoCode.
+- **File Reference Shortcuts**: Use `Cmd+Option+K` (Mac) or `Alt+Ctrl+K` (Linux/Windows) to insert file references. For example, `@File#L37-42`.
+
+---
+
+## Installation
+
+To install NeoCode on VS Code and popular forks like Cursor, Windsurf, VSCodium:
+
+1. Open VS Code
+2. Open the integrated terminal
+3. Run `neocode` - the extension installs automatically
+
+If on the other hand you want to use your own IDE when you run `/editor` or `/export` from the TUI, you'll need to set `export EDITOR="code --wait"`. [Learn more](/docs/tui/#editor-setup).
+
+---
+
+### Manual Install
+
+Search for **NeoCode** in the Extension Marketplace and click **Install**.
+
+---
+
+### Troubleshooting
+
+If the extension fails to install automatically:
+
+- Ensure you’re running `neocode` in the integrated terminal.
+- Confirm the CLI for your IDE is installed:
+  - For VS Code: `code` command
+  - For Cursor: `cursor` command
+  - For Windsurf: `windsurf` command
+  - For VSCodium: `codium` command
+  - If not, run `Cmd+Shift+P` (Mac) or `Ctrl+Shift+P` (Windows/Linux) and search for "Shell Command: Install 'code' command in PATH" (or the equivalent for your IDE)
+- Ensure VS Code has permission to install extensions