docs: Enhanced Video Playback Guidance

Docs: restructure docs to follow the Claude Code organization

.allstar/branch_protection.yaml

@@ -0,0 +1 @@
+action: 'log'

.aoneci/workflows/ci.yml

@@ -1,69 +1,69 @@
 # .aoneci/workflows/ci.yml
 
-name: Qwen Code CI
+name: 'Qwen Code CI'
 
 triggers:
   push:
-    branches: [main, dev, integration]
+    branches: ['main', 'dev', 'integration']
   merge_request:
 
 jobs:
   build:
-    name: Build and Lint
+    name: 'Build and Lint'
     steps:
-      - uses: checkout
-      - uses: setup-env
+      - uses: 'checkout'
+      - uses: 'setup-env'
         inputs:
           node-version: '20'
 
-      - name: Install dependencies
-        run: npm ci
+      - name: 'Install dependencies'
+        run: 'npm ci'
 
-      - name: Run formatter check
+      - name: 'Run formatter check'
         run: |
           npm run format
           git diff --exit-code
 
-      - name: Run linter
-        run: npm run lint:ci
+      - name: 'Run linter'
+        run: 'npm run lint:ci'
 
-      - name: Build project
-        run: npm run build
+      - name: 'Build project'
+        run: 'npm run build'
 
-      - name: Run type check
-        run: npm run typecheck
+      - name: 'Run type check'
+        run: 'npm run typecheck'
 
-      - name: Upload build artifacts
-        uses: upload-artifact
+      - name: 'Upload build artifacts'
+        uses: 'upload-artifact'
         inputs:
-          name: build-artifacts-20
+          name: 'build-artifacts-20'
           path: |
             packages/*/dist/**/*
             package-lock.json
 
   test:
-    name: Test
-    needs: build # This job depends on the 'build' job
+    name: 'Test'
+    needs: 'build' # This job depends on the 'build' job
     steps:
-      - uses: checkout
+      - uses: 'checkout'
 
-      - uses: setup-env
+      - uses: 'setup-env'
         inputs:
           node-version: '20'
 
-      - uses: download-artifact
+      - uses: 'download-artifact'
         inputs:
-          name: build-artifacts-20
-          path: .
+          name: 'build-artifacts-20'
+          path: '.'
 
-      - name: Install dependencies for testing
-        run: npm ci
+      - name: 'Install dependencies for testing'
+        run: 'npm ci'
 
-      - name: Run tests and generate reports
-        run: NO_COLOR=true npm run test:ci
+      - name: 'Run tests and generate reports'
+        run: 'NO_COLOR=true npm run test:ci'
 
-      - name: Upload coverage reports
-        uses: upload-artifact
+      - name: 'Upload coverage reports'
+        uses: 'upload-artifact'
         inputs:
-          name: coverage-reports-20
-          path: packages/*/coverage
+          name: 'coverage-reports-20'
+          path: 'packages/*/coverage'

.gcp/release-docker.yml

@@ -22,19 +22,15 @@ steps:
     id: 'Determine Docker Image Tag'
     entrypoint: 'bash'
     args:
-      - -c
-      - |
+      - '-c'
+      - |-
         SHELL_TAG_NAME="$TAG_NAME"
         FINAL_TAG="$SHORT_SHA" # Default to SHA
-        if [[ "$$SHELL_TAG_NAME" == *"-nightly"* ]]; then
-          echo "Nightly release detected."
-          FINAL_TAG="$${SHELL_TAG_NAME#v}"
-        # Also escape the variable in the regex match
-        elif [[ "$$SHELL_TAG_NAME" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-          echo "Official release detected."
+        if [[ "$$SHELL_TAG_NAME" =~ ^v[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.-]+)?$ ]]; then
+          echo "Release detected."
           FINAL_TAG="$${SHELL_TAG_NAME#v}"
         else
-          echo "Development/RC release detected. Using commit SHA as tag."
+          echo "Development release detected. Using commit SHA as tag."
         fi
         echo "Determined image tag: $$FINAL_TAG"
         echo "$$FINAL_TAG" > /workspace/image_tag.txt
@@ -44,8 +40,8 @@ steps:
     id: 'Build sandbox Docker image'
     entrypoint: 'bash'
     args:
-      - -c
-      - |
+      - '-c'
+      - |-
         export GEMINI_SANDBOX_IMAGE_TAG=$$(cat /workspace/image_tag.txt)
         echo "Using Docker image tag for build: $$GEMINI_SANDBOX_IMAGE_TAG"
         npm run build:sandbox -- --output-file /workspace/final_image_uri.txt
@@ -57,8 +53,8 @@ steps:
     id: 'Publish sandbox Docker image'
     entrypoint: 'bash'
     args:
-      - -c
-      - |
+      - '-c'
+      - |-
         set -e
         FINAL_IMAGE_URI=$$(cat /workspace/final_image_uri.txt)
 
@@ -68,7 +64,7 @@ steps:
       - 'GEMINI_SANDBOX=$_CONTAINER_TOOL'
 
 options:
-  defaultLogsBucketBehavior: REGIONAL_USER_OWNED_BUCKET
+  defaultLogsBucketBehavior: 'REGIONAL_USER_OWNED_BUCKET'
   dynamicSubstitutions: true
 
 substitutions:

.github/CODEOWNERS

@@ -1,7 +0,0 @@
-# By default, require reviews from the release approvers for all files.
-* @google-gemini/gemini-cli-askmode-approvers
-
-# The following files don't need reviews from the release approvers.
-# These patterns override the rule above.
-**/*.md
-/docs/

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,37 +1,40 @@
-name: Bug Report
-description: Report a bug to help us improve Qwen Code
-labels: ['kind/bug', 'status/need-triage']
+name: 'Bug Report'
+description: 'Report a bug to help us improve Qwen Code'
+labels: ['type/bug', 'status/needs-triage']
 body:
-  - type: markdown
+  - type: 'markdown'
     attributes:
-      value: |
-        > [!IMPORTANT]  
+      value: |-
+        > [!IMPORTANT]
         > Thanks for taking the time to fill out this bug report!
         >
         > Please search **[existing issues](https://github.com/QwenLM/qwen-code/issues)** to see if an issue already exists for the bug you encountered.
 
-  - type: textarea
-    id: problem
+  - type: 'textarea'
+    id: 'problem'
     attributes:
-      label: What happened?
-      description: A clear and concise description of what the bug is.
+      label: 'What happened?'
+      description: 'A clear and concise description of what the bug is.'
     validations:
       required: true
 
-  - type: textarea
-    id: expected
+  - type: 'textarea'
+    id: 'expected'
     attributes:
-      label: What did you expect to happen?
+      label: 'What did you expect to happen?'
     validations:
       required: true
 
-  - type: textarea
-    id: info
+  - type: 'textarea'
+    id: 'info'
     attributes:
-      label: Client information
-      description: Please paste the full text from the `/about` command run from Qwen Code. Also include which platform (macOS, Windows, Linux).
+      label: 'Client information'
+      description: 'Please paste the full text from the `/about` command run from Qwen Code. Also include which platform (macOS, Windows, Linux).'
       value: |
         <details>
+        <summary>Client Information</summary>
+
+        Run `qwen` to enter the interactive CLI, then run the `/about` command.
 
         ```console
         $ qwen /about
@@ -42,14 +45,14 @@ body:
     validations:
       required: true
 
-  - type: textarea
-    id: login-info
+  - type: 'textarea'
+    id: 'login-info'
     attributes:
-      label: Login information
-      description: Describe how you are logging in (e.g., API Config).
+      label: 'Login information'
+      description: 'Describe how you are logging in (e.g., API Config).'
 
-  - type: textarea
-    id: additional-context
+  - type: 'textarea'
+    id: 'additional-context'
     attributes:
-      label: Anything else we need to know?
-      description: Add any other context about the problem here.
+      label: 'Anything else we need to know?'
+      description: 'Add any other context about the problem here.'

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,33 +1,35 @@
-name: Feature Request
-description: Suggest an idea for this project
-labels: ['kind/enhancement', 'status/need-triage']
+name: 'Feature Request'
+description: 'Suggest an idea for this project'
+labels:
+  - 'type/feature-request'
+  - 'status/needs-triage'
 body:
-  - type: markdown
+  - type: 'markdown'
     attributes:
-      value: |
-        > [!IMPORTANT]  
+      value: |-
+        > [!IMPORTANT]
         > Thanks for taking the time to suggest an enhancement!
         >
         > Please search **[existing issues](https://github.com/QwenLM/qwen-code/issues)** to see if a similar feature has already been requested.
 
-  - type: textarea
-    id: feature
+  - type: 'textarea'
+    id: 'feature'
     attributes:
-      label: What would you like to be added?
-      description: A clear and concise description of the enhancement.
+      label: 'What would you like to be added?'
+      description: 'A clear and concise description of the enhancement.'
     validations:
       required: true
 
-  - type: textarea
-    id: rationale
+  - type: 'textarea'
+    id: 'rationale'
     attributes:
-      label: Why is this needed?
-      description: A clear and concise description of why this enhancement is needed.
+      label: 'Why is this needed?'
+      description: 'A clear and concise description of why this enhancement is needed.'
     validations:
       required: true
 
-  - type: textarea
-    id: additional-context
+  - type: 'textarea'
+    id: 'additional-context'
     attributes:
-      label: Additional context
-      description: Add any other context or screenshots about the feature request here.
+      label: 'Additional context'
+      description: 'Add any other context or screenshots about the feature request here.'

.github/actions/post-coverage-comment/action.yml

@@ -27,79 +27,88 @@ inputs:
 runs:
   using: 'composite'
   steps:
-    - name: Prepare Coverage Comment
-      id: prep_coverage_comment
-      shell: bash
-      run: |
-        cli_json_file="${{ inputs.cli_json_file }}"
-        core_json_file="${{ inputs.core_json_file }}"
-        cli_full_text_summary_file="${{ inputs.cli_full_text_summary_file }}"
-        core_full_text_summary_file="${{ inputs.core_full_text_summary_file }}"
-        comment_file="coverage-comment.md"
-
+    - name: 'Prepare Coverage Comment'
+      id: 'prep_coverage_comment'
+      shell: 'bash'
+      env:
+        CLI_JSON_FILE: '${{ inputs.cli_json_file }}'
+        CORE_JSON_FILE: '${{ inputs.core_json_file }}'
+        CLI_FULL_TEXT_SUMMARY_FILE: '${{ inputs.cli_full_text_summary_file }}'
+        CORE_FULL_TEXT_SUMMARY_FILE: '${{ inputs.core_full_text_summary_file }}'
+        COMMENT_FILE: 'coverage-comment.md'
+        NODE_VERSION: '${{ inputs.node_version }}'
+        OS: '${{ inputs.os }}'
+      run: |-
         # Extract percentages using jq for the main table
-        if [ -f "$cli_json_file" ]; then
-          cli_lines_pct=$(jq -r '.total.lines.pct' "$cli_json_file")
-          cli_statements_pct=$(jq -r '.total.statements.pct' "$cli_json_file")
-          cli_functions_pct=$(jq -r '.total.functions.pct' "$cli_json_file")
-          cli_branches_pct=$(jq -r '.total.branches.pct' "$cli_json_file")
+        if [ -f "${CLI_JSON_FILE}" ]; then
+          cli_lines_pct="$(jq -r '.total.lines.pct' "${CLI_JSON_FILE}")"
+          cli_statements_pct="$(jq -r '.total.statements.pct' "${CLI_JSON_FILE}")"
+          cli_functions_pct="$(jq -r '.total.functions.pct' "${CLI_JSON_FILE}")"
+          cli_branches_pct="$(jq -r '.total.branches.pct' "${CLI_JSON_FILE}")"
         else
-          cli_lines_pct="N/A"; cli_statements_pct="N/A"; cli_functions_pct="N/A"; cli_branches_pct="N/A"
-          echo "CLI coverage-summary.json not found at: $cli_json_file" >&2 # Error to stderr
+          cli_lines_pct="N/A"
+          cli_statements_pct="N/A"
+          cli_functions_pct="N/A"
+          cli_branches_pct="N/A"
+          echo "CLI coverage-summary.json not found at: ${CLI_JSON_FILE}" >&2 # Error to stderr
         fi
 
-        if [ -f "$core_json_file" ]; then
-          core_lines_pct=$(jq -r '.total.lines.pct' "$core_json_file")
-          core_statements_pct=$(jq -r '.total.statements.pct' "$core_json_file")
-          core_functions_pct=$(jq -r '.total.functions.pct' "$core_json_file")
-          core_branches_pct=$(jq -r '.total.branches.pct' "$core_json_file")
+        if [ -f "${CORE_JSON_FILE}" ]; then
+          core_lines_pct="$(jq -r '.total.lines.pct' "${CORE_JSON_FILE}")"
+          core_statements_pct="$(jq -r '.total.statements.pct' "${CORE_JSON_FILE}")"
+          core_functions_pct="$(jq -r '.total.functions.pct' "${CORE_JSON_FILE}")"
+          core_branches_pct="$(jq -r '.total.branches.pct' "${CORE_JSON_FILE}")"
         else
-          core_lines_pct="N/A"; core_statements_pct="N/A"; core_functions_pct="N/A"; core_branches_pct="N/A"
-          echo "Core coverage-summary.json not found at: $core_json_file" >&2 # Error to stderr
+          core_lines_pct="N/A"
+          core_statements_pct="N/A"
+          core_functions_pct="N/A"
+          core_branches_pct="N/A"
+          echo "Core coverage-summary.json not found at: ${CORE_JSON_FILE}" >&2 # Error to stderr
         fi
 
-        echo "## Code Coverage Summary" > "$comment_file"
-        echo "" >> "$comment_file"
-        echo "| Package | Lines | Statements | Functions | Branches |" >> "$comment_file"
-        echo "|---|---|---|---|---|" >> "$comment_file"
-        echo "| CLI | ${cli_lines_pct}% | ${cli_statements_pct}% | ${cli_functions_pct}% | ${cli_branches_pct}% |" >> "$comment_file"
-        echo "| Core | ${core_lines_pct}% | ${core_statements_pct}% | ${core_functions_pct}% | ${core_branches_pct}% |" >> "$comment_file"
-        echo "" >> "$comment_file"
+        echo "## Code Coverage Summary" > "${COMMENT_FILE}"
+        echo "" >> "${COMMENT_FILE}"
+        echo "| Package | Lines | Statements | Functions | Branches |" >> "${COMMENT_FILE}"
+        echo "|---|---|---|---|---|" >> "${COMMENT_FILE}"
+        echo "| CLI | ${cli_lines_pct}% | ${cli_statements_pct}% | ${cli_functions_pct}% | ${cli_branches_pct}% |" >> "${COMMENT_FILE}"
+        echo "| Core | ${core_lines_pct}% | ${core_statements_pct}% | ${core_functions_pct}% | ${core_branches_pct}% |" >> "${COMMENT_FILE}"
+        echo "" >> "${COMMENT_FILE}"
 
         # CLI Package - Collapsible Section (with full text summary from file)
-        echo "<details>" >> "$comment_file"
-        echo "<summary>CLI Package - Full Text Report</summary>" >> "$comment_file"
-        echo "" >> "$comment_file"
-        echo '```text' >> "$comment_file"
-        if [ -f "$cli_full_text_summary_file" ]; then
-          cat "$cli_full_text_summary_file" >> "$comment_file"
+        echo "<details>" >> "${COMMENT_FILE}"
+        echo "<summary>CLI Package - Full Text Report</summary>" >> "${COMMENT_FILE}"
+        echo "" >> "${COMMENT_FILE}"
+        echo '```text' >> "${COMMENT_FILE}"
+        if [ -f "${CLI_FULL_TEXT_SUMMARY_FILE}" ]; then
+          cat "${CLI_FULL_TEXT_SUMMARY_FILE}" >> "${COMMENT_FILE}"
         else
-          echo "CLI full-text-summary.txt not found at: $cli_full_text_summary_file" >> "$comment_file"
+          echo "CLI full-text-summary.txt not found at: ${CLI_FULL_TEXT_SUMMARY_FILE}" >> "${COMMENT_FILE}"
         fi
-        echo '```' >> "$comment_file"
-        echo "</details>" >> "$comment_file"
-        echo "" >> "$comment_file"
+        echo '```' >> "${COMMENT_FILE}"
+        echo "</details>" >> "${COMMENT_FILE}"
+        echo "" >> "${COMMENT_FILE}"
 
         # Core Package - Collapsible Section (with full text summary from file)
-        echo "<details>" >> "$comment_file"
-        echo "<summary>Core Package - Full Text Report</summary>" >> "$comment_file"
-        echo "" >> "$comment_file"
-        echo '```text' >> "$comment_file"
-        if [ -f "$core_full_text_summary_file" ]; then
-          cat "$core_full_text_summary_file" >> "$comment_file"
+        echo "<details>" >> "${COMMENT_FILE}"
+        echo "<summary>Core Package - Full Text Report</summary>" >> "${COMMENT_FILE}"
+        echo "" >> "${COMMENT_FILE}"
+        echo '```text' >> "${COMMENT_FILE}"
+        if [ -f "${CORE_FULL_TEXT_SUMMARY_FILE}" ]; then
+          cat "${CORE_FULL_TEXT_SUMMARY_FILE}" >> "${COMMENT_FILE}"
         else
-          echo "Core full-text-summary.txt not found at: $core_full_text_summary_file" >> "$comment_file"
+          echo "Core full-text-summary.txt not found at: ${CORE_FULL_TEXT_SUMMARY_FILE}" >> "${COMMENT_FILE}"
         fi
-        echo '```' >> "$comment_file"
-        echo "</details>" >> "$comment_file"
-        echo "" >> "$comment_file"
+        echo '```' >> "${COMMENT_FILE}"
+        echo "</details>" >> "${COMMENT_FILE}"
+        echo "" >> "${COMMENT_FILE}"
 
-        echo "_For detailed HTML reports, please see the 'coverage-reports-${{ inputs.node_version }}-${{ inputs.os }}' artifact from the main CI run._" >> "$comment_file"
+        echo "_For detailed HTML reports, please see the 'coverage-reports-${NODE_VERSION}-${OS}' artifact from the main CI run._" >> "${COMMENT_FILE}"
 
-    - name: Post Coverage Comment
-      uses: thollander/actions-comment-pull-request@v3
-      if: always()
+    - name: 'Post Coverage Comment'
+      uses: 'thollander/actions-comment-pull-request@65f9e5c9a1f2cd378bd74b2e057c9736982a8e74' # ratchet:thollander/actions-comment-pull-request@v3
+      if: |-
+        ${{ always() }}
       with:
-        file-path: coverage-comment.md # Use the generated file directly
-        comment-tag: code-coverage-summary
-        github-token: ${{ inputs.github_token }}
+        file-path: 'coverage-comment.md' # Use the generated file directly
+        comment-tag: 'code-coverage-summary'
+        github-token: '${{ inputs.github_token }}'

.github/dependabot.yml

@@ -0,0 +1,35 @@
+# See https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+version: 2
+updates:
+  - package-ecosystem: 'npm'
+    directory: '/'
+    schedule:
+      interval: 'daily'
+    target-branch: 'main'
+    commit-message:
+      prefix: 'chore(deps)'
+      include: 'scope'
+    reviewers:
+      - 'google-gemini/gemini-cli-askmode-approvers'
+    groups:
+      # Group all non-major updates together.
+      # This is to reduce the number of PRs that need to be reviewed.
+      # Major updates will still be created as separate PRs.
+      npm-minor-patch:
+        applies-to: 'version-updates'
+        update-types:
+          - 'minor'
+          - 'patch'
+    open-pull-requests-limit: 0
+
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'daily'
+    target-branch: 'main'
+    commit-message:
+      prefix: 'chore(deps)'
+      include: 'scope'
+    reviewers:
+      - 'google-gemini/gemini-cli-askmode-approvers'
+    open-pull-requests-limit: 0

.github/scripts/pr-triage.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -euo pipefail
 
 # Initialize a comma-separated string to hold PR numbers that need a comment
@@ -6,81 +6,69 @@ PRS_NEEDING_COMMENT=""
 
 # Function to process a single PR
 process_pr() {
-    local PR_NUMBER=$1
-    echo "🔄 Processing PR #$PR_NUMBER"
-
-    # Get PR body with error handling
-    local PR_BODY
-    if ! PR_BODY=$(gh pr view "$PR_NUMBER" --repo "$GITHUB_REPOSITORY" --json body -q .body 2>/dev/null); then
-        echo "   ⚠️ Could not fetch PR #$PR_NUMBER details"
+    if [[ -z "${GITHUB_REPOSITORY:-}" ]]; then
+        echo "‼️ Missing \$GITHUB_REPOSITORY - this must be run from GitHub Actions"
         return 1
     fi
 
-    # Look for issue references using multiple patterns
-    local ISSUE_NUMBER=""
-
-    # Pattern 1: Direct reference like #123
-    if [ -z "$ISSUE_NUMBER" ]; then
-        ISSUE_NUMBER=$(echo "$PR_BODY" | grep -oE '#[0-9]+' | head -1 | sed 's/#//' 2>/dev/null || echo "")
+    if [[ -z "${GITHUB_OUTPUT:-}" ]]; then
+        echo "‼️ Missing \$GITHUB_OUTPUT - this must be run from GitHub Actions"
+        return 1
     fi
 
-    # Pattern 2: Closes/Fixes/Resolves patterns (case-insensitive)
-    if [ -z "$ISSUE_NUMBER" ]; then
-        ISSUE_NUMBER=$(echo "$PR_BODY" | grep -iE '(closes?|fixes?|resolves?) #[0-9]+' | grep -oE '#[0-9]+' | head -1 | sed 's/#//' 2>/dev/null || echo "")
+    local PR_NUMBER=$1
+    echo "🔄 Processing PR #${PR_NUMBER}"
+
+    # Get closing issue number with error handling
+    local ISSUE_NUMBER
+    if ! ISSUE_NUMBER=$(gh pr view "${PR_NUMBER}" --repo "${GITHUB_REPOSITORY}" --json closingIssuesReferences -q '.closingIssuesReferences.nodes[0].number' 2>/dev/null); then
+        echo "   ⚠️ Could not fetch closing issue for PR #${PR_NUMBER}"
     fi
 
-    if [ -z "$ISSUE_NUMBER" ]; then
-        echo "⚠️  No linked issue found for PR #$PR_NUMBER, adding status/need-issue label"
-        if ! gh pr edit "$PR_NUMBER" --repo "$GITHUB_REPOSITORY" --add-label "status/need-issue" 2>/dev/null; then
-            echo "   ⚠️ Failed to add label (may already exist or have permission issues)"
-        fi
-        # Add PR number to the list
-        if [ -z "$PRS_NEEDING_COMMENT" ]; then
-            PRS_NEEDING_COMMENT="$PR_NUMBER"
-        else
-            PRS_NEEDING_COMMENT="$PRS_NEEDING_COMMENT,$PR_NUMBER"
-        fi
-        echo "needs_comment=true" >> $GITHUB_OUTPUT
+    if [[ -z "${ISSUE_NUMBER}" ]]; then
+        echo "ℹ️  No linked issue found for PR #${PR_NUMBER} - this is acceptable for independent contributions"
+        # We no longer require PRs to have linked issues
+        # Independent valuable contributions are encouraged
     else
-        echo "🔗 Found linked issue #$ISSUE_NUMBER"
+        echo "🔗 Found linked issue #${ISSUE_NUMBER}"
 
-        # Remove status/need-issue label if present
-        if ! gh pr edit "$PR_NUMBER" --repo "$GITHUB_REPOSITORY" --remove-label "status/need-issue" 2>/dev/null; then
+        # Remove status/need-issue label if present (legacy cleanup)
+        if ! gh pr edit "${PR_NUMBER}" --repo "${GITHUB_REPOSITORY}" --remove-label "status/need-issue" 2>/dev/null; then
             echo "   status/need-issue label not present or could not be removed"
         fi
 
         # Get issue labels
-        echo "📥 Fetching labels from issue #$ISSUE_NUMBER"
+        echo "📥 Fetching labels from issue #${ISSUE_NUMBER}"
         local ISSUE_LABELS=""
-        if ! ISSUE_LABELS=$(gh issue view "$ISSUE_NUMBER" --repo "$GITHUB_REPOSITORY" --json labels -q '.labels[].name' 2>/dev/null | tr '\n' ',' | sed 's/,$//' || echo ""); then
-            echo "   ⚠️ Could not fetch issue #$ISSUE_NUMBER (may not exist or be in different repo)"
+        if ! ISSUE_LABELS=$(gh issue view "${ISSUE_NUMBER}" --repo "${GITHUB_REPOSITORY}" --json labels -q '.labels[].name' 2>/dev/null | tr '\n' ',' | sed 's/,$//' || echo ""); then
+            echo "   ⚠️ Could not fetch issue #${ISSUE_NUMBER} (may not exist or be in different repo)"
             ISSUE_LABELS=""
         fi
 
         # Get PR labels
-        echo "📥 Fetching labels from PR #$PR_NUMBER"
+        echo "📥 Fetching labels from PR #${PR_NUMBER}"
         local PR_LABELS=""
-        if ! PR_LABELS=$(gh pr view "$PR_NUMBER" --repo "$GITHUB_REPOSITORY" --json labels -q '.labels[].name' 2>/dev/null | tr '\n' ',' | sed 's/,$//' || echo ""); then
+        if ! PR_LABELS=$(gh pr view "${PR_NUMBER}" --repo "${GITHUB_REPOSITORY}" --json labels -q '.labels[].name' 2>/dev/null | tr '\n' ',' | sed 's/,$//' || echo ""); then
             echo "   ⚠️ Could not fetch PR labels"
             PR_LABELS=""
         fi
 
-        echo "   Issue labels: $ISSUE_LABELS"
-        echo "   PR labels: $PR_LABELS"
+        echo "   Issue labels: ${ISSUE_LABELS}"
+        echo "   PR labels: ${PR_LABELS}"
 
         # Convert comma-separated strings to arrays
         local ISSUE_LABEL_ARRAY PR_LABEL_ARRAY
-        IFS=',' read -ra ISSUE_LABEL_ARRAY <<< "$ISSUE_LABELS"
-        IFS=',' read -ra PR_LABEL_ARRAY <<< "$PR_LABELS"
+        IFS=',' read -ra ISSUE_LABEL_ARRAY <<< "${ISSUE_LABELS}"
+        IFS=',' read -ra PR_LABEL_ARRAY <<< "${PR_LABELS}"
 
         # Find labels to add (on issue but not on PR)
         local LABELS_TO_ADD=""
         for label in "${ISSUE_LABEL_ARRAY[@]}"; do
-            if [ -n "$label" ] && [[ ! " ${PR_LABEL_ARRAY[*]} " =~ " ${label} " ]]; then
-                if [ -z "$LABELS_TO_ADD" ]; then
-                    LABELS_TO_ADD="$label"
+            if [[ -n "${label}" ]] && [[ " ${PR_LABEL_ARRAY[*]} " != *" ${label} "* ]]; then
+                if [[ -z "${LABELS_TO_ADD}" ]]; then
+                    LABELS_TO_ADD="${label}"
                 else
-                    LABELS_TO_ADD="$LABELS_TO_ADD,$label"
+                    LABELS_TO_ADD="${LABELS_TO_ADD},${label}"
                 fi
             fi
         done
@@ -88,65 +76,58 @@ process_pr() {
         # Find labels to remove (on PR but not on issue)
         local LABELS_TO_REMOVE=""
         for label in "${PR_LABEL_ARRAY[@]}"; do
-            if [ -n "$label" ] && [[ ! " ${ISSUE_LABEL_ARRAY[*]} " =~ " ${label} " ]]; then
-                # Don't remove status/need-issue since we already handled it
-                if [ "$label" != "status/need-issue" ]; then
-                    if [ -z "$LABELS_TO_REMOVE" ]; then
-                        LABELS_TO_REMOVE="$label"
+            if [[ -n "${label}" ]] && [[ " ${ISSUE_LABEL_ARRAY[*]} " != *" ${label} "* ]]; then
+                # Don't remove status/need-issue since we already handled it (legacy cleanup)
+                if [[ "${label}" != "status/need-issue" ]]; then
+                    if [[ -z "${LABELS_TO_REMOVE}" ]]; then
+                        LABELS_TO_REMOVE="${label}"
                     else
-                        LABELS_TO_REMOVE="$LABELS_TO_REMOVE,$label"
+                        LABELS_TO_REMOVE="${LABELS_TO_REMOVE},${label}"
                     fi
                 fi
             fi
         done
 
         # Apply label changes
-        if [ -n "$LABELS_TO_ADD" ]; then
-            echo "➕ Adding labels: $LABELS_TO_ADD"
-            if ! gh pr edit "$PR_NUMBER" --repo "$GITHUB_REPOSITORY" --add-label "$LABELS_TO_ADD" 2>/dev/null; then
+        if [[ -n "${LABELS_TO_ADD}" ]]; then
+            echo "➕ Adding labels: ${LABELS_TO_ADD}"
+            if ! gh pr edit "${PR_NUMBER}" --repo "${GITHUB_REPOSITORY}" --add-label "${LABELS_TO_ADD}" 2>/dev/null; then
                 echo "   ⚠️ Failed to add some labels"
             fi
         fi
 
-        if [ -n "$LABELS_TO_REMOVE" ]; then
-            echo "➖ Removing labels: $LABELS_TO_REMOVE"
-            if ! gh pr edit "$PR_NUMBER" --repo "$GITHUB_REPOSITORY" --remove-label "$LABELS_TO_REMOVE" 2>/dev/null; then
-                echo "   ⚠️ Failed to remove some labels"
-            fi
-        fi
-
-        if [ -z "$LABELS_TO_ADD" ] && [ -z "$LABELS_TO_REMOVE" ]; then
+        if [[ -z "${LABELS_TO_ADD}" ]]; then
             echo "✅ Labels already synchronized"
         fi
-        echo "needs_comment=false" >> $GITHUB_OUTPUT
+        echo "needs_comment=false" >> "${GITHUB_OUTPUT}"
     fi
 }
 
 # If PR_NUMBER is set, process only that PR
-if [ -n "${PR_NUMBER:-}" ]; then
-    if ! process_pr "$PR_NUMBER"; then
-        echo "❌ Failed to process PR #$PR_NUMBER"
+if [[ -n "${PR_NUMBER:-}" ]]; then
+    if ! process_pr "${PR_NUMBER}"; then
+        echo "❌ Failed to process PR #${PR_NUMBER}"
         exit 1
     fi
 else
     # Otherwise, get all open PRs and process them
     # The script logic will determine which ones need issue linking or label sync
     echo "📥 Getting all open pull requests..."
-    if ! PR_NUMBERS=$(gh pr list --repo "$GITHUB_REPOSITORY" --state open --limit 1000 --json number -q '.[].number' 2>/dev/null); then
+    if ! PR_NUMBERS=$(gh pr list --repo "${GITHUB_REPOSITORY}" --state open --limit 1000 --json number -q '.[].number' 2>/dev/null); then
         echo "❌ Failed to fetch PR list"
         exit 1
     fi
-    
-    if [ -z "$PR_NUMBERS" ]; then
+
+    if [[ -z "${PR_NUMBERS}" ]]; then
         echo "✅ No open PRs found"
     else
         # Count the number of PRs
-        PR_COUNT=$(echo "$PR_NUMBERS" | wc -w | tr -d ' ')
-        echo "📊 Found $PR_COUNT open PRs to process"
-        
-        for pr_number in $PR_NUMBERS; do
-            if ! process_pr "$pr_number"; then
-                echo "⚠️ Failed to process PR #$pr_number, continuing with next PR..."
+        PR_COUNT=$(echo "${PR_NUMBERS}" | wc -w | tr -d ' ')
+        echo "📊 Found ${PR_COUNT} open PRs to process"
+
+        for pr_number in ${PR_NUMBERS}; do
+            if ! process_pr "${pr_number}"; then
+                echo "⚠️ Failed to process PR #${pr_number}, continuing with next PR..."
                 continue
             fi
         done
@@ -154,10 +135,10 @@ else
 fi
 
 # Ensure output is always set, even if empty
-if [ -z "$PRS_NEEDING_COMMENT" ]; then
-    echo "prs_needing_comment=[]" >> $GITHUB_OUTPUT
+if [[ -z "${PRS_NEEDING_COMMENT}" ]]; then
+    echo "prs_needing_comment=[]" >> "${GITHUB_OUTPUT}"
 else
-    echo "prs_needing_comment=[$PRS_NEEDING_COMMENT]" >> $GITHUB_OUTPUT
+    echo "prs_needing_comment=[${PRS_NEEDING_COMMENT}]" >> "${GITHUB_OUTPUT}"
 fi
 
-echo "✅ PR triage completed"
+echo "✅ PR triage completed"

.github/workflows/build-and-publish-image.yml

@@ -0,0 +1,67 @@
+name: 'Build and Publish Docker Image'
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: 'Publish to GHCR (only works on main branch)'
+        type: 'boolean'
+        default: false
+
+env:
+  REGISTRY: 'ghcr.io'
+  IMAGE_NAME: '${{ github.repository }}'
+
+jobs:
+  build-and-push-to-ghcr:
+    runs-on: 'ubuntu-latest'
+    permissions:
+      contents: 'read'
+      packages: 'write'
+
+    steps:
+      - name: 'Checkout repository'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
+
+      - name: 'Set up QEMU'
+        uses: 'docker/setup-qemu-action@v3' # ratchet:exclude
+
+      - name: 'Set up Docker Buildx'
+        uses: 'docker/setup-buildx-action@v3' # ratchet:exclude
+
+      - name: 'Extract metadata (tags, labels) for Docker'
+        id: 'meta'
+        uses: 'docker/metadata-action@v5' # ratchet:exclude
+        with:
+          images: '${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}'
+          tags: |
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=sha,prefix=sha-,format=short
+
+      - name: 'Log in to the Container registry'
+        if: |-
+          ${{ github.event_name != 'pull_request' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v') || github.event.inputs.publish == 'true') }}
+        uses: 'docker/login-action@v3' # ratchet:exclude
+        with:
+          registry: '${{ env.REGISTRY }}'
+          username: '${{ github.actor }}'
+          password: '${{ secrets.GITHUB_TOKEN }}'
+
+      - name: 'Build and push Docker image'
+        id: 'build-and-push'
+        uses: 'docker/build-push-action@v6' # ratchet:exclude
+        with:
+          context: '.'
+          platforms: 'linux/amd64,linux/arm64'
+          push: |-
+            ${{ github.event_name != 'pull_request' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v') || github.event.inputs.publish == 'true') }}
+          tags: '${{ steps.meta.outputs.tags }}'
+          labels: '${{ steps.meta.outputs.labels }}'
+          build-args: |
+            CLI_VERSION_ARG=${{ github.sha }}

.github/workflows/check-issue-completeness.yml

@@ -0,0 +1,201 @@
+name: 'Check Issue Completeness'
+
+on:
+  issues:
+    types:
+      - 'opened'
+      - 'edited'
+
+permissions:
+  contents: 'read'
+  issues: 'write'
+
+jobs:
+  check-issue-info:
+    timeout-minutes: 2
+    if: |-
+      ${{ github.repository == 'QwenLM/qwen-code' && contains(github.event.issue.labels.*.name, 'type/bug') }}
+    runs-on: 'ubuntu-latest'
+    steps:
+      - name: 'Check for Client Information'
+        id: 'check_info'
+        env:
+          ISSUE_BODY: '${{ github.event.issue.body }}'
+        run: |-
+          echo "Checking issue body for required information..."
+
+          # Convert issue body to lowercase for case-insensitive matching
+          ISSUE_BODY_LOWER=$(echo "$ISSUE_BODY" | tr '[:upper:]' '[:lower:]')
+
+          # Initialize flags
+          HAS_VERSION=false
+          HAS_OS_INFO=false
+          HAS_AUTH_METHOD=false
+          HAS_ABOUT_OUTPUT=false
+          MISSING_INFO=()
+
+          # Check for /about command output by looking for its characteristic fields
+          # The /about output contains: CLI Version, Git Commit, Model, Sandbox, OS, Auth Method
+          if echo "$ISSUE_BODY_LOWER" | grep -qE 'cli version.*[0-9]+\.[0-9]+\.[0-9]+'; then
+            HAS_ABOUT_OUTPUT=true
+            HAS_VERSION=true
+          fi
+
+          # If full /about output is not detected, check individual components
+          if [ "$HAS_ABOUT_OUTPUT" = false ]; then
+            # Check for version information (various formats)
+            if echo "$ISSUE_BODY_LOWER" | grep -qE '(cli version|version|v)[[:space:]]*[0-9]+\.[0-9]+\.[0-9]+'; then
+              HAS_VERSION=true
+            fi
+
+            # Check for OS information
+            if echo "$ISSUE_BODY_LOWER" | grep -qE '(^os[[:space:]]|macos|windows|linux|ubuntu|debian|fedora|arch|darwin|win32|platform)'; then
+              HAS_OS_INFO=true
+            fi
+
+            # Check for Auth Method information
+            if echo "$ISSUE_BODY_LOWER" | grep -qE '(auth method|authentication|login|qwen-oauth|api.?config|oauth)'; then
+              HAS_AUTH_METHOD=true
+            fi
+          else
+            # If /about output is present, assume it contains OS and auth info
+            HAS_OS_INFO=true
+            HAS_AUTH_METHOD=true
+          fi
+
+          # Determine what's missing
+          if [ "$HAS_ABOUT_OUTPUT" = false ]; then
+            if [ "$HAS_VERSION" = false ]; then
+              MISSING_INFO+=("Qwen Code version")
+            fi
+            if [ "$HAS_OS_INFO" = false ]; then
+              MISSING_INFO+=("operating system information")
+            fi
+            if [ "$HAS_AUTH_METHOD" = false ]; then
+              MISSING_INFO+=("authentication/login method")
+            fi
+            # Suggest providing /about output for completeness
+            if [ "$HAS_VERSION" = false ] || [ "$HAS_OS_INFO" = false ] || [ "$HAS_AUTH_METHOD" = false ]; then
+              MISSING_INFO+=("full output of the \`/about\` command (recommended)")
+            fi
+          fi
+
+          # Set output variables
+          if [ ${#MISSING_INFO[@]} -eq 0 ]; then
+            echo "info_complete=true" >> "$GITHUB_OUTPUT"
+            echo "All required information is present."
+          else
+            echo "info_complete=false" >> "$GITHUB_OUTPUT"
+            # Join array elements with comma
+            MISSING_LIST=$(IFS=','; echo "${MISSING_INFO[*]}")
+            echo "missing_info=$MISSING_LIST" >> "$GITHUB_OUTPUT"
+            echo "Missing information: $MISSING_LIST"
+          fi
+
+      - name: 'Comment on Issue if Information is Missing'
+        if: |-
+          ${{ steps.check_info.outputs.info_complete == 'false' }}
+        uses: 'actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea' # ratchet:actions/github-script@v7
+        env:
+          MISSING_INFO: '${{ steps.check_info.outputs.missing_info }}'
+        with:
+          github-token: '${{ secrets.GITHUB_TOKEN }}'
+          script: |
+            const missingInfo = process.env.MISSING_INFO.split(',');
+            const missingList = missingInfo.map(item => `- ${item}`).join('\n');
+
+            const comments = await github.rest.issues.listComments({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+            });
+
+            const botComment = comments.data.find(comment =>
+              comment.user.type === 'Bot' &&
+              comment.body.includes('Missing Required Information')
+            );
+
+            const commentBody = `### ⚠️ Missing Required Information
+
+            Thank you for reporting this issue! To help us investigate and resolve this problem more effectively, we need some additional information:
+
+            ${missingList}
+
+            ### How to provide this information:
+
+            Please run the following command and paste the complete output:
+
+            \`\`\`bash
+            qwen
+            # Then in the interactive CLI, run:
+            /about
+            \`\`\`
+
+            The output should look like:
+            \`\`\`
+            CLI Version             0.0.14
+            Git Commit              9a0cb64a
+            Model                   coder-model
+            Sandbox                 no sandbox
+            OS                      darwin
+            Auth Method             qwen-oauth
+            \`\`\`
+
+            Once you provide this information, we'll be able to assist you better. Thank you! 🙏`;
+
+            if (botComment) {
+              await github.rest.issues.updateComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                comment_id: botComment.id,
+                body: commentBody
+              });
+              console.log('Updated existing comment about missing information.');
+            } else {
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+                body: commentBody
+              });
+              console.log('Created new comment about missing information.');
+            }
+
+      - name: 'Add status/need-information Label'
+        if: |-
+          ${{ steps.check_info.outputs.info_complete == 'false' }}
+        uses: 'actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea' # ratchet:actions/github-script@v7
+        with:
+          github-token: '${{ secrets.GITHUB_TOKEN }}'
+          script: |
+            await github.rest.issues.addLabels({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+              labels: ['status/need-information']
+            });
+            console.log('Added status/need-information label.');
+
+      - name: 'Remove status/need-information Label if Complete'
+        if: |-
+          ${{ steps.check_info.outputs.info_complete == 'true' }}
+        uses: 'actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea' # ratchet:actions/github-script@v7
+        continue-on-error: true
+        with:
+          github-token: '${{ secrets.GITHUB_TOKEN }}'
+          script: |
+            try {
+              await github.rest.issues.removeLabel({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+                name: 'status/need-information'
+              });
+              console.log('Removed status/need-information label as information is now complete.');
+            } catch (error) {
+              if (error.status === 404) {
+                console.log('Label not found on issue, nothing to remove.');
+              } else {
+                throw error;
+              }
+            }

.github/workflows/ci.yml

@@ -1,153 +1,222 @@
 # .github/workflows/ci.yml
 
-name: Qwen Code CI
+name: 'Qwen Code CI'
 
 on:
   push:
-    branches: [main, release]
+    branches:
+      - 'main'
+      - 'release/**'
   pull_request:
-    branches: [main, release]
+    branches:
+      - 'main'
+      - 'release/**'
   merge_group:
+  workflow_dispatch:
+    inputs:
+      branch_ref:
+        description: 'Branch to run on'
+        required: true
+        default: 'main'
+        type: 'string'
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.head_ref || github.ref }}'
+  cancel-in-progress: |-
+    ${{ github.ref != 'refs/heads/main' && !startsWith(github.ref, 'refs/heads/release/') }}
+
+permissions:
+  checks: 'write'
+  contents: 'read'
+  statuses: 'write'
+
+defaults:
+  run:
+    shell: 'bash'
+
+env:
+  ACTIONLINT_VERSION: '1.7.7'
+  SHELLCHECK_VERSION: '0.11.0'
+  YAMLLINT_VERSION: '1.35.1'
 
 jobs:
   lint:
-    name: Lint
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read # For checkout
+    name: 'Lint'
+    runs-on: 'ubuntu-latest'
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - name: 'Checkout'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
+        with:
+          ref: '${{ github.event.inputs.branch_ref || github.ref }}'
+          fetch-depth: 0
 
-      - name: Set up Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      - name: 'Set up Node.js'
+        uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4.4.0
         with:
           node-version-file: '.nvmrc'
           cache: 'npm'
 
-      - name: Install dependencies
-        run: npm ci
+      - name: 'Install dependencies'
+        run: 'npm ci'
 
-      - name: Run formatter check
-        run: |
-          npm run format
-          git diff --exit-code
+      - name: 'Check lockfile'
+        run: 'npm run check:lockfile'
 
-      - name: Run linter
-        run: npm run lint:ci
+      - name: 'Install linters'
+        run: 'node scripts/lint.js --setup'
 
-      - name: Build project
-        run: npm run build
+      - name: 'Run ESLint'
+        run: 'node scripts/lint.js --eslint'
 
-      - name: Run type check
-        run: npm run typecheck
+      - name: 'Run actionlint'
+        run: 'node scripts/lint.js --actionlint'
 
+      - name: 'Run shellcheck'
+        run: 'node scripts/lint.js --shellcheck'
+
+      - name: 'Run yamllint'
+        run: 'node scripts/lint.js --yamllint'
+
+      - name: 'Run Prettier'
+        run: 'node scripts/lint.js --prettier'
+
+      - name: 'Run sensitive keyword linter'
+        run: 'node scripts/lint.js --sensitive-keywords'
+
+  #
+  # Test: Node
+  #
   test:
-    name: Test
-    runs-on: ${{ matrix.os }}
-    needs: lint
+    name: 'Test'
+    runs-on: '${{ matrix.os }}'
+    needs:
+      - 'lint'
     permissions:
-      contents: read
-      checks: write
-      pull-requests: write
+      contents: 'read'
+      checks: 'write'
+      pull-requests: 'write'
     strategy:
+      fail-fast: false # So we can see all test failures
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        node-version: [20.x, 22.x, 24.x]
+        os:
+          - 'macos-latest'
+          - 'ubuntu-latest'
+          - 'windows-latest'
+        node-version:
+          - '20.x'
+          - '22.x'
+          - '24.x'
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - name: 'Checkout'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
 
-      - name: Set up Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      - name: 'Set up Node.js ${{ matrix.node-version }}'
+        uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4
         with:
-          node-version: ${{ matrix.node-version }}
+          node-version: '${{ matrix.node-version }}'
           cache: 'npm'
+          cache-dependency-path: 'package-lock.json'
+          registry-url: 'https://registry.npmjs.org/'
 
-      - name: Build project
-        run: npm run build
+      - name: 'Configure npm for rate limiting'
+        run: |-
+          npm config set fetch-retry-mintimeout 20000
+          npm config set fetch-retry-maxtimeout 120000
+          npm config set fetch-retries 5
+          npm config set fetch-timeout 300000
 
-      - name: Install dependencies for testing
-        run: npm ci # Install fresh dependencies using the downloaded package-lock.json
+      - name: 'Install dependencies'
+        run: |-
+          npm ci --prefer-offline --no-audit --progress=false
 
-      - name: Run tests and generate reports
-        run: npm run test:ci
+      - name: 'Build project'
+        run: |-
+          npm run build
+
+      - name: 'Run tests and generate reports'
         env:
           NO_COLOR: true
+        run: 'npm run test:ci'
 
-      - name: Publish Test Report (for non-forks)
-        if: always() && (github.event.pull_request.head.repo.full_name == github.repository)
-        uses: dorny/test-reporter@dc3a92680fcc15842eef52e8c4606ea7ce6bd3f3 # v2
+      - name: 'Publish Test Report (for non-forks)'
+        if: |-
+          ${{ always() && (github.event.pull_request.head.repo.full_name == github.repository) }}
+        uses: 'dorny/test-reporter@dc3a92680fcc15842eef52e8c4606ea7ce6bd3f3' # ratchet:dorny/test-reporter@v2
         with:
-          name: Test Results (Node ${{ matrix.node-version }})
-          path: packages/*/junit.xml
-          reporter: java-junit
+          name: 'Test Results (Node ${{ matrix.node-version }})'
+          path: 'packages/*/junit.xml'
+          reporter: 'java-junit'
           fail-on-error: 'false'
 
-      - name: Upload Test Results Artifact (for forks)
-        if: always() && (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository)
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+      - name: 'Upload Test Results Artifact (for forks)'
+        if: |-
+          ${{ always() && (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository) }}
+        uses: 'actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02' # ratchet:actions/upload-artifact@v4
         with:
-          name: test-results-fork-${{ matrix.node-version }}-${{ matrix.os }}
-          path: packages/*/junit.xml
+          name: 'test-results-fork-${{ matrix.node-version }}-${{ matrix.os }}'
+          path: 'packages/*/junit.xml'
 
-      - name: Upload coverage reports
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
-        if: always()
+      - name: 'Upload coverage reports'
+        if: |-
+          ${{ always() }}
+        uses: 'actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02' # ratchet:actions/upload-artifact@v4
         with:
-          name: coverage-reports-${{ matrix.node-version }}-${{ matrix.os }}
-          path: packages/*/coverage
+          name: 'coverage-reports-${{ matrix.node-version }}-${{ matrix.os }}'
+          path: 'packages/*/coverage'
 
   post_coverage_comment:
-    name: Post Coverage Comment
-    runs-on: ubuntu-latest
-    needs: test
-    if: always() && github.event_name == 'pull_request' && (github.event.pull_request.head.repo.full_name == github.repository)
+    name: 'Post Coverage Comment'
+    runs-on: 'ubuntu-latest'
+    needs: 'test'
+    if: |-
+      ${{ always() && github.event_name == 'pull_request' && (github.event.pull_request.head.repo.full_name == github.repository) }}
     continue-on-error: true
     permissions:
-      contents: read # For checkout
-      pull-requests: write # For commenting
+      contents: 'read' # For checkout
+      pull-requests: 'write' # For commenting
     strategy:
       matrix:
         # Reduce noise by only posting the comment once
-        os: [ubuntu-latest]
-        node-version: [22.x]
+        os:
+          - 'ubuntu-latest'
+        node-version:
+          - '22.x'
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - name: 'Checkout'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
 
-      - name: Download coverage reports artifact
-        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
+      - name: 'Download coverage reports artifact'
+        uses: 'actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0' # ratchet:actions/download-artifact@v5
         with:
-          name: coverage-reports-${{ matrix.node-version }}-${{ matrix.os }}
-          path: coverage_artifact # Download to a specific directory
+          name: 'coverage-reports-${{ matrix.node-version }}-${{ matrix.os }}'
+          path: 'coverage_artifact' # Download to a specific directory
 
-      - name: Post Coverage Comment using Composite Action
-        uses: ./.github/actions/post-coverage-comment # Path to the composite action directory
+      - name: 'Post Coverage Comment using Composite Action'
+        uses: './.github/actions/post-coverage-comment' # Path to the composite action directory
         with:
-          cli_json_file: coverage_artifact/cli/coverage/coverage-summary.json
-          core_json_file: coverage_artifact/core/coverage/coverage-summary.json
-          cli_full_text_summary_file: coverage_artifact/cli/coverage/full-text-summary.txt
-          core_full_text_summary_file: coverage_artifact/core/coverage/full-text-summary.txt
-          node_version: ${{ matrix.node-version }}
-          os: ${{ matrix.os }}
-          github_token: ${{ secrets.GITHUB_TOKEN }}
+          cli_json_file: 'coverage_artifact/cli/coverage/coverage-summary.json'
+          core_json_file: 'coverage_artifact/core/coverage/coverage-summary.json'
+          cli_full_text_summary_file: 'coverage_artifact/cli/coverage/full-text-summary.txt'
+          core_full_text_summary_file: 'coverage_artifact/core/coverage/full-text-summary.txt'
+          node_version: '${{ matrix.node-version }}'
+          os: '${{ matrix.os }}'
+          github_token: '${{ secrets.GITHUB_TOKEN }}'
 
   codeql:
-    name: CodeQL
-    runs-on: ubuntu-latest
+    name: 'CodeQL'
+    runs-on: 'ubuntu-latest'
     permissions:
-      actions: read
-      contents: read
-      security-events: write
+      actions: 'read'
+      contents: 'read'
+      security-events: 'write'
     steps:
-      - name: Checkout
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - name: 'Checkout'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
 
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@181d5eefc20863364f96762470ba6f862bdef56b # v3
+      - name: 'Initialize CodeQL'
+        uses: 'github/codeql-action/init@df559355d593797519d70b90fc8edd5db049e7a2' # ratchet:github/codeql-action/init@v3
         with:
-          languages: javascript
+          languages: 'javascript'
 
-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@181d5eefc20863364f96762470ba6f862bdef56b # v3
+      - name: 'Perform CodeQL Analysis'
+        uses: 'github/codeql-action/analyze@df559355d593797519d70b90fc8edd5db049e7a2' # ratchet:github/codeql-action/analyze@v3

.github/workflows/community-report.yml

@@ -1,4 +1,4 @@
-name: Generate Weekly Community Report 📊
+name: 'Generate Weekly Community Report 📊'
 
 on:
   schedule:
@@ -12,56 +12,61 @@ on:
 
 jobs:
   generate-report:
-    name: Generate Report 📝
-    if: ${{ github.repository == 'google-gemini/gemini-cli' }}
-    runs-on: ubuntu-latest
+    name: 'Generate Report 📝'
+    if: |-
+      ${{ github.repository == 'google-gemini/gemini-cli' }}
+    runs-on: 'ubuntu-latest'
     permissions:
-      issues: write
-      pull-requests: read
-      discussions: read
-      contents: read
-      id-token: write
+      issues: 'write'
+      pull-requests: 'read'
+      discussions: 'read'
+      contents: 'read'
+      id-token: 'write'
 
     steps:
-      - name: Generate GitHub App Token 🔑
-        id: generate_token
-        uses: actions/create-github-app-token@df432ceedc7162793a195dd1713ff69aefc7379e # v2
+      - name: 'Generate GitHub App Token 🔑'
+        id: 'generate_token'
+        uses: 'actions/create-github-app-token@a8d616148505b5069dccd32f177bb87d7f39123b' # ratchet:actions/create-github-app-token@v2
         with:
-          app-id: ${{ secrets.APP_ID }}
-          private-key: ${{ secrets.PRIVATE_KEY }}
+          app-id: '${{ secrets.APP_ID }}'
+          private-key: '${{ secrets.PRIVATE_KEY }}'
+          permission-issues: 'write'
+          permission-pull-requests: 'read'
+          permission-discussions: 'read'
+          permission-contents: 'read'
 
-      - name: Generate Report 📜
-        id: report
+      - name: 'Generate Report 📜'
+        id: 'report'
         env:
-          GH_TOKEN: ${{ steps.generate_token.outputs.token }}
-          REPO: ${{ github.repository }}
-          DAYS: ${{ github.event.inputs.days || '7' }}
-        run: |
+          GH_TOKEN: '${{ steps.generate_token.outputs.token }}'
+          REPO: '${{ github.repository }}'
+          DAYS: '${{ github.event.inputs.days || 7 }}'
+        run: |-
           set -e
 
-          START_DATE=$(date -u -d "$DAYS days ago" +'%Y-%m-%d')
-          END_DATE=$(date -u +'%Y-%m-%d')
-          echo "⏳ Generating report for contributions from $START_DATE to $END_DATE..."
+          START_DATE="$(date -u -d "$DAYS days ago" +'%Y-%m-%d')"
+          END_DATE="$(date -u +'%Y-%m-%d')"
+          echo "⏳ Generating report for contributions from ${START_DATE} to ${END_DATE}..."
 
           declare -A author_is_googler
           check_googler_status() {
-              local author=$1
-              if [[ "$author" == *"[bot]" ]]; then
-                  author_is_googler[$author]=1
+              local author="$1"
+              if [[ "${author}" == *"[bot]" ]]; then
+                  author_is_googler[${author}]=1
                   return 1
               fi
-              if [[ -v "author_is_googler[$author]" ]]; then
-                  return ${author_is_googler[$author]}
+              if [[ -v "author_is_googler[${author}]" ]]; then
+                  return "${author_is_googler[${author}]}"
               fi
 
-              if gh api "orgs/googlers/members/$author" --silent 2>/dev/null; then
-                  echo "🧑‍💻 $author is a Googler."
-                  author_is_googler[$author]=0
+              if gh api "orgs/googlers/members/${author}" --silent 2>/dev/null; then
+                  echo "🧑‍💻 ${author} is a Googler."
+                  author_is_googler[${author}]=0
               else
-                  echo "🌍 $author is a community contributor."
-                  author_is_googler[$author]=1
+                  echo "🌍 ${author} is a community contributor."
+                  author_is_googler[${author}]=1
               fi
-              return ${author_is_googler[$author]}
+              return "${author_is_googler[${author}]}"
           }
 
           googler_issues=0
@@ -70,27 +75,27 @@ jobs:
           non_googler_prs=0
 
           echo "🔎 Fetching issues and pull requests..."
-          ITEMS_JSON=$(gh search issues --repo "$REPO" "created:>$START_DATE" --json author,isPullRequest --limit 1000)
+          ITEMS_JSON="$(gh search issues --repo "${REPO}" "created:>${START_DATE}" --json author,isPullRequest --limit 1000)"
 
           for row in $(echo "${ITEMS_JSON}" | jq -r '.[] | @base64'); do
               _jq() {
-                  echo ${row} | base64 --decode | jq -r ${1}
+                  echo "${row}" | base64 --decode | jq -r "${1}"
               }
-              author=$(_jq '.author.login')
-              is_pr=$(_jq '.isPullRequest')
+              author="$(_jq '.author.login')"
+              is_pr="$(_jq '.isPullRequest')"
 
-              if [[ -z "$author" || "$author" == "null" ]]; then
+              if [[ -z "${author}" || "${author}" == "null" ]]; then
                 continue
               fi
 
-              if check_googler_status "$author"; then
-                  if [[ "$is_pr" == "true" ]]; then
+              if check_googler_status "${author}"; then
+                  if [[ "${is_pr}" == "true" ]]; then
                       ((googler_prs++))
                   else
                       ((googler_issues++))
                   fi
               else
-                  if [[ "$is_pr" == "true" ]]; then
+                  if [[ "${is_pr}" == "true" ]]; then
                       ((non_googler_prs++))
                   else
                       ((non_googler_issues++))
@@ -114,19 +119,19 @@ jobs:
               }
             }
           }'''
-          DISCUSSIONS_JSON=$(gh api graphql -f q="repo:$REPO created:>$START_DATE" -f query="$DISCUSSION_QUERY")
+          DISCUSSIONS_JSON="$(gh api graphql -f q="repo:${REPO} created:>${START_DATE}" -f query="${DISCUSSION_QUERY}")"
 
           for row in $(echo "${DISCUSSIONS_JSON}" | jq -r '.data.search.nodes[] | @base64'); do
               _jq() {
-                  echo ${row} | base64 --decode | jq -r ${1}
+                  echo "${row}" | base64 --decode | jq -r "${1}"
               }
-              author=$(_jq '.author.login')
+              author="$(_jq '.author.login')"
 
-              if [[ -z "$author" || "$author" == "null" ]]; then
+              if [[ -z "${author}" || "${author}" == "null" ]]; then
                 continue
               fi
 
-              if check_googler_status "$author"; then
+              if check_googler_status "${author}"; then
                   ((googler_discussions++))
               else
                   ((non_googler_discussions++))
@@ -134,7 +139,6 @@ jobs:
           done
 
           echo "✍️ Generating report content..."
-          REPORT_TITLE="Community Contribution Report: $START_DATE to $END_DATE"
           TOTAL_ISSUES=$((googler_issues + non_googler_issues))
           TOTAL_PRS=$((googler_prs + non_googler_prs))
           TOTAL_DISCUSSIONS=$((googler_discussions + non_googler_discussions))
@@ -142,7 +146,7 @@ jobs:
           REPORT_BODY=$(cat <<EOF
           ### 💖 Community Contribution Report
 
-          **Period:** $START_DATE to $END_DATE
+          **Period:** ${START_DATE} to ${END_DATE}
 
           | Category | Googlers | Community | Total |
           |---|---:|---:|---:|
@@ -154,24 +158,29 @@ jobs:
           EOF
           )
 
-          echo "report_body<<EOF" >> $GITHUB_OUTPUT
-          echo "$REPORT_BODY" >> $GITHUB_OUTPUT
-          echo "EOF" >> $GITHUB_OUTPUT
+          echo "report_body<<EOF" >> "${GITHUB_OUTPUT}"
+          echo "${REPORT_BODY}" >> "${GITHUB_OUTPUT}"
+          echo "EOF" >> "${GITHUB_OUTPUT}"
 
           echo "📊 Community Contribution Report:"
-          echo "$REPORT_BODY"
+          echo "${REPORT_BODY}"
 
-      - name: 🤖 Get Insights from Report
-        if: steps.report.outputs.report_body != ''
-        uses: google-gemini/gemini-cli-action@df3f890f003d28c60a2a09d2c29e0126e4d1e2ff
+      - name: '🤖 Get Insights from Report'
+        if: |-
+          ${{ steps.report.outputs.report_body != '' }}
+        uses: 'google-github-actions/run-gemini-cli@a3bf79042542528e91937b3a3a6fbc4967ee3c31' # ratchet:google-github-actions/run-gemini-cli@v0
         env:
-          GITHUB_TOKEN: ${{ steps.generate_token.outputs.token }}
+          GITHUB_TOKEN: '${{ steps.generate_token.outputs.token }}'
+          REPOSITORY: '${{ github.repository }}'
         with:
-          version: 0.1.8-rc.0
-          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
-          OTLP_GCP_WIF_PROVIDER: ${{ secrets.OTLP_GCP_WIF_PROVIDER }}
-          OTLP_GOOGLE_CLOUD_PROJECT: ${{ secrets.OTLP_GOOGLE_CLOUD_PROJECT }}
-          settings_json: |
+          gcp_workload_identity_provider: '${{ vars.GCP_WIF_PROVIDER }}'
+          gcp_project_id: '${{ vars.GOOGLE_CLOUD_PROJECT }}'
+          gcp_location: '${{ vars.GOOGLE_CLOUD_LOCATION }}'
+          gcp_service_account: '${{ vars.SERVICE_ACCOUNT_EMAIL }}'
+          gemini_api_key: '${{ secrets.GEMINI_API_KEY }}'
+          use_vertex_ai: '${{ vars.GOOGLE_GENAI_USE_VERTEXAI }}'
+          use_gemini_code_assist: '${{ vars.GOOGLE_GENAI_USE_GCA }}'
+          settings: |-
             {
               "coreTools": [
                 "run_shell_command(gh issue list)",
@@ -180,7 +189,7 @@ jobs:
                 "run_shell_command(gh search prs)"
               ]
             }
-          prompt: |
+          prompt: |-
             You are a helpful assistant that analyzes community contribution reports.
             Based on the following report, please provide a brief summary and highlight any interesting trends or potential areas for improvement.
 

.github/workflows/docs-page-action.yml

@@ -0,0 +1,50 @@
+name: 'Deploy GitHub Pages'
+
+on:
+  push:
+    tags: 'v*'
+  workflow_dispatch:
+
+permissions:
+  contents: 'read'
+  pages: 'write'
+  id-token: 'write'
+
+# Allow only one concurrent deployment, skipping runs queued between the run
+# in-progress and latest queued. However, do NOT cancel in-progress runs as we
+# want to allow these production deployments to complete.
+concurrency:
+  group: '${{ github.workflow }}'
+  cancel-in-progress: false
+
+jobs:
+  build:
+    if: |-
+      ${{ !contains(github.ref_name, 'nightly') }}
+    runs-on: 'ubuntu-latest'
+    steps:
+      - name: 'Checkout'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
+
+      - name: 'Setup Pages'
+        uses: 'actions/configure-pages@983d7736d9b0ae728b81ab479565c72886d7745b' # ratchet:actions/configure-pages@v5
+
+      - name: 'Build with Jekyll'
+        uses: 'actions/jekyll-build-pages@44a6e6beabd48582f863aeeb6cb2151cc1716697' # ratchet:actions/jekyll-build-pages@v1
+        with:
+          source: './'
+          destination: './_site'
+
+      - name: 'Upload artifact'
+        uses: 'actions/upload-pages-artifact@56afc609e74202658d3ffba0e8f6dda462b719fa' # ratchet:actions/upload-pages-artifact@v3
+
+  deploy:
+    environment:
+      name: 'github-pages'
+      url: '${{ steps.deployment.outputs.page_url }}'
+    runs-on: 'ubuntu-latest'
+    needs: 'build'
+    steps:
+      - name: 'Deploy to GitHub Pages'
+        id: 'deployment'
+        uses: 'actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e' # ratchet:actions/deploy-pages@v4

.github/workflows/e2e.yml

@@ -1,77 +1,110 @@
-# .github/workflows/e2e.yml
-
-name: E2E Tests
+name: 'E2E Tests'
 
 on:
   push:
-    branches: [main]
+    branches:
+      - 'main'
+      - 'feat/e2e/**'
   merge_group:
 
 jobs:
   e2e-test-linux:
-    name: E2E Test (Linux) - ${{ matrix.sandbox }}
-    runs-on: ubuntu-latest
+    name: 'E2E Test (Linux) - ${{ matrix.sandbox }}'
+    runs-on: 'ubuntu-latest'
     strategy:
       matrix:
-        sandbox: [sandbox:none, sandbox:docker]
-        node-version: [20.x, 22.x, 24.x]
+        sandbox:
+          - 'sandbox:none'
+          - 'sandbox:docker'
+        node-version:
+          - '20.x'
+          - '22.x'
+          - '24.x'
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - name: 'Checkout'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
 
-      - name: Set up Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      - name: 'Set up Node.js ${{ matrix.node-version }}'
+        uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4
         with:
-          node-version: ${{ matrix.node-version }}
+          node-version: '${{ matrix.node-version }}'
           cache: 'npm'
+          cache-dependency-path: 'package-lock.json'
+          registry-url: 'https://registry.npmjs.org/'
 
-      - name: Install dependencies
-        run: npm ci
+      - name: 'Configure npm for rate limiting'
+        run: |-
+          npm config set fetch-retry-mintimeout 20000
+          npm config set fetch-retry-maxtimeout 120000
+          npm config set fetch-retries 5
+          npm config set fetch-timeout 300000
 
-      - name: Build project
-        run: npm run build
+      - name: 'Install dependencies'
+        run: |-
+          npm ci --prefer-offline --no-audit --progress=false
 
-      - name: Set up Docker
-        if: matrix.sandbox == 'sandbox:docker'
-        uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3
+      - name: 'Build project'
+        run: |-
+          npm run build
 
-      - name: Set up Podman
-        if: matrix.sandbox == 'sandbox:podman'
-        uses: redhat-actions/podman-login@4934294ad0449894bcd1e9f191899d7292469603 # v1
+      - name: 'Set up Docker'
+        if: |-
+          ${{ matrix.sandbox == 'sandbox:docker' }}
+        uses: 'docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435' # ratchet:docker/setup-buildx-action@v3
+
+      - name: 'Set up Podman'
+        if: |-
+          ${{ matrix.sandbox == 'sandbox:podman' }}
+        uses: 'redhat-actions/podman-login@4934294ad0449894bcd1e9f191899d7292469603' # ratchet:redhat-actions/podman-login@v1
         with:
-          registry: docker.io
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
+          registry: 'docker.io'
+          username: '${{ secrets.DOCKERHUB_USERNAME }}'
+          password: '${{ secrets.DOCKERHUB_TOKEN }}'
 
-      - name: Run E2E tests
+      - name: 'Run E2E tests'
         env:
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          OPENAI_BASE_URL: ${{ secrets.OPENAI_BASE_URL }}
-          OPENAI_MODEL: ${{ secrets.OPENAI_MODEL }}
-        run: npm run test:integration:${{ matrix.sandbox }} -- --verbose --keep-output
+          OPENAI_API_KEY: '${{ secrets.OPENAI_API_KEY }}'
+          OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'
+          OPENAI_MODEL: '${{ secrets.OPENAI_MODEL }}'
+          KEEP_OUTPUT: 'true'
+          SANDBOX: '${{ matrix.sandbox }}'
+          VERBOSE: 'true'
+        run: |-
+          npm run "test:integration:${SANDBOX}"
 
   e2e-test-macos:
-    name: E2E Test - macOS
-    runs-on: macos-latest
+    name: 'E2E Test - macOS'
+    runs-on: 'macos-latest'
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - name: 'Checkout'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
 
-      - name: Set up Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      - name: 'Set up Node.js'
+        uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4
         with:
-          node-version: 20.x
+          node-version-file: '.nvmrc'
           cache: 'npm'
+          cache-dependency-path: 'package-lock.json'
+          registry-url: 'https://registry.npmjs.org/'
 
-      - name: Install dependencies
-        run: npm ci
+      - name: 'Configure npm for rate limiting'
+        run: |-
+          npm config set fetch-retry-mintimeout 20000
+          npm config set fetch-retry-maxtimeout 120000
+          npm config set fetch-retries 5
+          npm config set fetch-timeout 300000
 
-      - name: Build project
-        run: npm run build
+      - name: 'Install dependencies'
+        run: |-
+          npm ci --prefer-offline --no-audit --progress=false
 
-      - name: Run E2E tests
+      - name: 'Build project'
+        run: |-
+          npm run build
+
+      - name: 'Run E2E tests'
         env:
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          OPENAI_BASE_URL: ${{ secrets.OPENAI_BASE_URL }}
-          OPENAI_MODEL: ${{ secrets.OPENAI_MODEL }}
-        run: npm run test:e2e
+          OPENAI_API_KEY: '${{ secrets.OPENAI_API_KEY }}'
+          OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'
+          OPENAI_MODEL: '${{ secrets.OPENAI_MODEL }}'
+        run: 'npm run test:e2e'

.github/workflows/eval.yml

@@ -0,0 +1,29 @@
+name: 'Eval'
+
+on:
+  workflow_dispatch:
+
+jobs:
+  eval:
+    name: 'Eval'
+    runs-on: 'ubuntu-latest'
+    strategy:
+      matrix:
+        node-version:
+          - '20.x'
+          - '22.x'
+          - '24.x'
+    steps:
+      - name: 'Set up Node.js ${{ matrix.node-version }}'
+        uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4
+        with:
+          node-version: '${{ matrix.node-version }}'
+          cache: 'npm'
+
+      - name: 'Set up Python'
+        uses: 'actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065' # ratchet:actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: 'Install and configure Poetry'
+        uses: 'snok/install-poetry@76e04a911780d5b312d89783f7b1cd627778900a' # ratchet:snok/install-poetry@v1

.github/workflows/gemini-automated-issue-dedup.yml

@@ -0,0 +1,262 @@
+name: '🏷️ Gemini Automated Issue Deduplication'
+
+on:
+  issues:
+    types:
+      - 'opened'
+      - 'reopened'
+  issue_comment:
+    types:
+      - 'created'
+  workflow_dispatch:
+    inputs:
+      issue_number:
+        description: 'issue number to dedup'
+        required: true
+        type: 'number'
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.event.issue.number }}'
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: 'bash'
+
+jobs:
+  find-duplicates:
+    if: |-
+      github.repository == 'google-gemini/gemini-cli' &&
+      vars.TRIAGE_DEDUPLICATE_ISSUES != '' &&
+      (github.event_name == 'issues' ||
+       github.event_name == 'workflow_dispatch' ||
+       (github.event_name == 'issue_comment' &&
+       contains(github.event.comment.body, '@gemini-cli /deduplicate') &&
+       (github.event.comment.author_association == 'OWNER' ||
+        github.event.comment.author_association == 'MEMBER' ||
+        github.event.comment.author_association == 'COLLABORATOR')))
+    permissions:
+      contents: 'read'
+      id-token: 'write' # Required for WIF, see https://docs.github.com/en/actions/how-tos/secure-your-work/security-harden-deployments/oidc-in-google-cloud-platform#adding-permissions-settings
+      issues: 'read'
+      statuses: 'read'
+      packages: 'read'
+    timeout-minutes: 20
+    runs-on: 'ubuntu-latest'
+    outputs:
+      duplicate_issues_csv: '${{ env.DUPLICATE_ISSUES_CSV }}'
+    steps:
+      - name: 'Checkout'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
+
+      - name: 'Log in to GitHub Container Registry'
+        uses: 'docker/login-action@184bdaa0721073962dff0199f1fb9940f07167d1' # ratchet:docker/login-action@v3
+        with:
+          registry: 'ghcr.io'
+          username: '${{ github.actor }}'
+          password: '${{ secrets.GITHUB_TOKEN }}'
+
+      - name: 'Find Duplicate Issues'
+        uses: 'google-github-actions/run-gemini-cli@a3bf79042542528e91937b3a3a6fbc4967ee3c31' # ratchet:google-github-actions/run-gemini-cli@v0
+        id: 'gemini_issue_deduplication'
+        env:
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          ISSUE_TITLE: '${{ github.event.issue.title }}'
+          ISSUE_BODY: '${{ github.event.issue.body }}'
+          ISSUE_NUMBER: '${{ github.event.issue.number }}'
+          REPOSITORY: '${{ github.repository }}'
+          FIRESTORE_PROJECT: '${{ vars.FIRESTORE_PROJECT }}'
+        with:
+          gcp_workload_identity_provider: '${{ vars.GCP_WIF_PROVIDER }}'
+          gcp_project_id: '${{ vars.GOOGLE_CLOUD_PROJECT }}'
+          gcp_location: '${{ vars.GOOGLE_CLOUD_LOCATION }}'
+          gcp_service_account: '${{ vars.SERVICE_ACCOUNT_EMAIL }}'
+          gemini_api_key: '${{ secrets.GEMINI_API_KEY }}'
+          use_vertex_ai: '${{ vars.GOOGLE_GENAI_USE_VERTEXAI }}'
+          use_gemini_code_assist: '${{ vars.GOOGLE_GENAI_USE_GCA }}'
+          settings: |-
+            {
+              "mcpServers": {
+                "issue_deduplication": {
+                  "command": "docker",
+                  "args": [
+                    "run",
+                    "-i",
+                    "--rm",
+                    "--network", "host",
+                    "-e", "GITHUB_TOKEN",
+                    "-e", "GEMINI_API_KEY",
+                    "-e", "DATABASE_TYPE",
+                    "-e", "FIRESTORE_DATABASE_ID",
+                    "-e", "GCP_PROJECT",
+                    "-e", "GOOGLE_APPLICATION_CREDENTIALS=/app/gcp-credentials.json",
+                    "-v", "${GOOGLE_APPLICATION_CREDENTIALS}:/app/gcp-credentials.json",
+                    "ghcr.io/google-gemini/gemini-cli-issue-triage@sha256:e3de1523f6c83aabb3c54b76d08940a2bf42febcb789dd2da6f95169641f94d3"
+                  ],
+                  "env": {
+                    "GITHUB_TOKEN": "${GITHUB_TOKEN}",
+                    "GEMINI_API_KEY": "${{ secrets.GEMINI_API_KEY }}",
+                    "DATABASE_TYPE":"firestore",
+                    "GCP_PROJECT": "${FIRESTORE_PROJECT}",
+                    "FIRESTORE_DATABASE_ID": "(default)",
+                    "GOOGLE_APPLICATION_CREDENTIALS": "${GOOGLE_APPLICATION_CREDENTIALS}"
+                  },
+                  "enabled": true,
+                  "timeout": 600000
+                }
+              },
+              "maxSessionTurns": 25,
+              "coreTools": [
+                "run_shell_command(echo)",
+                "run_shell_command(gh issue view)"
+              ],
+              "telemetry": {
+                "enabled": true,
+                "target": "gcp"
+              }
+            }
+          prompt: |-
+            ## Role
+            You are an issue de-duplication assistant. Your goal is to find
+            duplicate issues for a given issue.
+            ## Steps
+            1.  **Find Potential Duplicates:**
+                - The repository is ${{ github.repository }} and the issue number is ${{ github.event.issue.number }}.
+                - Use the `duplicates` tool with the `repo` and `issue_number` to find potential duplicates for the current issue. Do not use the `threshold` parameter.
+                - If no duplicates are found, you are done.
+                - Print the JSON output from the `duplicates` tool to the logs.
+            2.  **Refine Duplicates List (if necessary):**
+                - If the `duplicates` tool returns between 1 and 14 results, you must refine the list.
+                - For each potential duplicate issue, run `gh issue view <issue-number> --json title,body,comments` to fetch its content.
+                - Also fetch the content of the original issue: `gh issue view "${ISSUE_NUMBER}" --json title,body,comments`.
+                - Carefully analyze the content (title, body, comments) of the original issue and all potential duplicates.
+                - It is very important if the comments on either issue mention that they are not duplicates of each other, to treat them as not duplicates.
+                - Based on your analysis, create a final list containing only the issues you are highly confident are actual duplicates.
+                - If your final list is empty, you are done.
+                - Print to the logs if you omitted any potential duplicates based on your analysis.
+                - If the `duplicates` tool returned 15+ results, use the top 15 matches (based on descending similarity score value) to perform this step.
+            3.  **Output final duplicates list as CSV:**
+                - Convert the list of appropriate duplicate issue numbers into a comma-separated list (CSV). If there are no appropriate duplicates, use the empty string.
+                - Use the "echo" shell command to append the CSV of issue numbers into the filepath referenced by the environment variable "${GITHUB_ENV}":
+                  echo "DUPLICATE_ISSUES_CSV=[DUPLICATE_ISSUES_AS_CSV]" >> "${GITHUB_ENV}"
+            ## Guidelines
+            - Only use the `duplicates` and `run_shell_command` tools.
+            - The `run_shell_command` tool can be used with `gh issue view`.
+            - Do not download or read media files like images, videos, or links. The `--json` flag for `gh issue view` will prevent this.
+            - Do not modify the issue content or status.
+            - Do not add comments or labels.
+            - Reference all shell variables as "${VAR}" (with quotes and braces).
+
+  add-comment-and-label:
+    needs: 'find-duplicates'
+    if: |-
+      github.repository == 'google-gemini/gemini-cli' &&
+      vars.TRIAGE_DEDUPLICATE_ISSUES != '' &&
+      needs.find-duplicates.outputs.duplicate_issues_csv != '' &&
+      (
+       github.event_name == 'issues' ||
+       github.event_name == 'workflow_dispatch' ||
+       (
+        github.event_name == 'issue_comment' &&
+        contains(github.event.comment.body, '@gemini-cli /deduplicate') &&
+        (
+         github.event.comment.author_association == 'OWNER' ||
+         github.event.comment.author_association == 'MEMBER' ||
+         github.event.comment.author_association == 'COLLABORATOR'
+        )
+       )
+      )
+    permissions:
+      issues: 'write'
+    timeout-minutes: 5
+    runs-on: 'ubuntu-latest'
+    steps:
+      - name: 'Generate GitHub App Token'
+        id: 'generate_token'
+        uses: 'actions/create-github-app-token@a8d616148505b5069dccd32f177bb87d7f39123b' # ratchet:actions/create-github-app-token@v2
+        with:
+          app-id: '${{ secrets.APP_ID }}'
+          private-key: '${{ secrets.PRIVATE_KEY }}'
+          permission-issues: 'write'
+
+      - name: 'Comment and Label Duplicate Issue'
+        uses: 'actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea'
+        env:
+          DUPLICATES_OUTPUT: '${{ needs.find-duplicates.outputs.duplicate_issues_csv }}'
+        with:
+          github-token: '${{ steps.generate_token.outputs.token || secrets.GITHUB_TOKEN }}'
+          script: |-
+            const rawCsv = process.env.DUPLICATES_OUTPUT;
+            core.info(`Raw duplicates CSV: ${rawCsv}`);
+            const duplicateIssues = rawCsv.split(',').map(s => s.trim()).filter(s => s);
+
+            if (duplicateIssues.length === 0) {
+              core.info('No duplicate issues found. Nothing to do.');
+              return;
+            }
+
+            const issueNumber = ${{ github.event.issue.number }};
+
+            function formatCommentBody(issues, updated = false) {
+              const header = updated
+                ? 'Found possible duplicate issues (updated):'
+                : 'Found possible duplicate issues:';
+              const issuesList = issues.map(num => `- #${num}`).join('\n');
+              const footer = 'If you believe this is not a duplicate, please remove the `status/possible-duplicate` label.';
+              const magicComment = '<!-- gemini-cli-deduplication -->';
+              return `${header}\n\n${issuesList}\n\n${footer}\n${magicComment}`;
+            }
+
+            const newCommentBody = formatCommentBody(duplicateIssues);
+            const newUpdatedCommentBody = formatCommentBody(duplicateIssues, true);
+
+            const { data: comments } = await github.rest.issues.listComments({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issueNumber,
+            });
+
+            const magicComment = '<!-- gemini-cli-deduplication -->';
+            const existingComment = comments.find(comment =>
+              comment.user.type === 'Bot' && comment.body.includes(magicComment)
+            );
+
+            let commentMade = false;
+
+            if (existingComment) {
+              // To check if lists are same, just compare the formatted bodies without headers.
+              const existingBodyForCompare = existingComment.body.substring(existingComment.body.indexOf('- #'));
+              const newBodyForCompare = newCommentBody.substring(newCommentBody.indexOf('- #'));
+
+              if (existingBodyForCompare.trim() !== newBodyForCompare.trim()) {
+                core.info(`Updating existing comment ${existingComment.id}`);
+                await github.rest.issues.updateComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  comment_id: existingComment.id,
+                  body: newUpdatedCommentBody,
+                });
+                commentMade = true;
+              } else {
+                core.info('Existing comment is up-to-date. Nothing to do.');
+              }
+            } else {
+              core.info('Creating new comment.');
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                body: newCommentBody,
+              });
+              commentMade = true;
+            }
+
+            if (commentMade) {
+              core.info('Adding "status/possible-duplicate" label.');
+              await github.rest.issues.addLabels({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                labels: ['status/possible-duplicate'],
+              });
+            }

.github/workflows/gemini-automated-issue-triage.yml

@@ -1,132 +0,0 @@
-name: Qwen Automated Issue Triage
-
-on:
-  issues:
-    types: [opened, reopened]
-
-jobs:
-  triage-issue:
-    timeout-minutes: 5
-    if: ${{ github.repository == 'QwenLM/qwen-code' }}
-    permissions:
-      issues: write
-      contents: read
-      id-token: write
-    concurrency:
-      group: ${{ github.workflow }}-${{ github.event.issue.number }}
-      cancel-in-progress: true
-    runs-on: ubuntu-latest
-    steps:
-      - name: Run Qwen Issue Triage
-        uses: QwenLM/qwen-code-action@5fd6818d04d64e87d255ee4d5f77995e32fbf4c2
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          ISSUE_TITLE: ${{ github.event.issue.title }}
-          ISSUE_BODY: ${{ github.event.issue.body }}
-        with:
-          version: 0.0.4
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          settings_json: |
-            {
-              "coreTools": [
-                "run_shell_command(gh label list)",
-                "run_shell_command(gh issue edit)",
-                "run_shell_command(gh issue list)"
-              ],
-              "sandbox": false
-            }
-          prompt: |
-            You are an issue triage assistant. Analyze the current GitHub issues apply the most appropriate existing labels. Do not remove labels titled help wanted or good first issue.
-            Steps:
-            1. Run: `gh label list --repo ${{ github.repository }} --limit 100` to get all available labels.
-            2. Review the issue title, body and any comments provided in the environment variables.
-            3. Ignore any existing priorities or tags on the issue. Just report your findings.
-            4. Select the most relevant labels from the existing labels, focusing on kind/*, area/*, sub-area/* and priority/*. For area/* and kind/* limit yourself to only the single most applicable label in each case. 
-            6. Apply the selected labels to this issue using: `gh issue edit ${{ github.event.issue.number }} --repo ${{ github.repository }} --add-label "label1,label2"`
-            7. For each issue please check if CLI version is present, this is usually in the output of the /about command  and will look like 0.1.5 for anything more than 6 versions older than the most recent should add the status/need-retesting label
-            8. If you see that the issue doesn’t look like it has sufficient information recommend the status/need-information label
-            9. Use Area definitions mentioned below to help you narrow down issues
-            Guidelines:
-            - Only use labels that already exist in the repository.
-            - Do not add comments or modify the issue content.
-            - Triage only the current issue.
-            - Apply only one area/ label
-            - Apply only one kind/ label
-            - Apply all applicable sub-area/* and priority/* labels based on the issue content. It's ok to have multiple of these.
-            - Once you categorize the issue if it needs information bump down the priority by 1 eg.. a p0 would become a p1 a p1 would become a p2. P2 and P3 can stay as is in this scenario.
-            Categorization Guidelines: 
-            P0: Critical / Blocker
-            - A P0 bug is a catastrophic failure that demands immediate attention. It represents a complete showstopper for a significant portion of users or for the development process itself.
-            Impact:
-            - Blocks development or testing for the entire team.
-            - Major security vulnerability that could compromise user data or system integrity.
-            - Causes data loss or corruption with no workaround.
-            - Crashes the application or makes a core feature completely unusable for all or most users in a production environment. Will it cause severe quality degration? Is it preventing contributors from contributing to the repository or is it a release blocker?
-            Qualifier: Is the main function of the software broken?
-            Example: The gemini auth login command fails with an unrecoverable error, preventing any user from authenticating and using the rest of the CLI.
-            P1: High
-            - A P1 bug is a serious issue that significantly degrades the user experience or impacts a core feature. While not a complete blocker, it's a major problem that needs a fast resolution. Feature requests are almost never P1.
-            Impact:
-            - A core feature is broken or behaving incorrectly for a large number of users or large number of use cases.
-            - Review the bug details and comments to try figure out if this issue affects a large set of use cases or if it's a narrow set of use cases.
-            - Severe performance degradation making the application frustratingly slow.
-            - No straightforward workaround exists, or the workaround is difficult and non-obvious.
-            Qualifier: Is a key feature unusable or giving very wrong results?
-            Example: The gemini -p "..." command consistently returns a malformed JSON response or an empty result, making the CLI's primary generation feature unreliable.
-            P2: Medium
-            - A P2 bug is a moderately impactful issue. It's a noticeable problem but doesn't prevent the use of the software's main functionality.
-            Impact:
-            - Affects a non-critical feature or a smaller, specific subset of users.
-            - An inconvenient but functional workaround is available and easy to execute.
-            - Noticeable UI/UX problems that don't break functionality but look unprofessional (e.g., elements are misaligned or overlapping).
-            Qualifier: Is it an annoying but non-blocking problem?
-            Example: An error message is unclear or contains a typo, causing user confusion but not halting their workflow.
-            P3: Low
-            - A P3 bug is a minor, low-impact issue that is trivial or cosmetic. It has little to no effect on the overall functionality of the application.
-            Impact:
-            - Minor cosmetic issues like color inconsistencies, typos in documentation, or slight alignment problems on a non-critical page.
-            - An edge-case bug that is very difficult to reproduce and affects a tiny fraction of users.
-            Qualifier: Is it a "nice-to-fix" issue?
-            Example: Spelling mistakes etc.
-            Things you should know:
-            - If users are talking about issues where the model gets downgraded from pro to flash then i want you to categorize that as a performance issue
-            - This product is designed to use different models eg.. using pro, downgrading to flash etc. when users report that they dont expect the model to change those would be categorized as feature requests.
-            Definition of Areas
-            area/ux: 
-            - Issues concerning user-facing elements like command usability, interactive features, help docs, and perceived performance.
-            - I am seeing my screen flicker when using Gemini CLI 
-            - I am seeing the output malformed 
-            - Theme changes aren't taking effect 
-            - My keyboard inputs arent' being recognzied
-            area/platform: 
-            - Issues related to installation, packaging, OS compatibility (Windows, macOS, Linux), and the underlying CLI framework.
-            area/background: Issues related to long-running background tasks, daemons, and autonomous or proactive agent features.
-            area/models: 
-            - i am not getting a response that is reasonable or expected. this can include things like
-            - I am calling a tool and the tool is not performing as expected.
-            - i am expecting a tool to be called and it is not getting called ,
-            - Including experience when using
-            - built-in tools (e.g., web search, code interpreter, read file, writefile, etc..),
-            - Function calling issues should be under this area
-            - i am getting responses from the model that are malformed.
-            - Issues concerning Gemini quality of response and inference,
-            - Issues talking about unnecessary token consumption.
-            - Issues talking about Model getting stuck in a loop be watchful as this could be the root cause for issues that otherwise seem like model performance issues.
-            - Memory compression
-            - unexpected responses,
-            - poor quality of generated code
-            area/tools: 
-            - These are primarily issues related to Model Context Protocol 
-            - These are issues that mention MCP support 
-            - feature requests asking for support for new tools. 
-            area/core: Issues with fundamental components like command parsing, configuration management, session state, and the main API client logic. Introducing multi-modality
-            area/contribution: Issues related to improving the developer contribution experience, such as CI/CD pipelines, build scripts, and test automation infrastructure.
-            area/authentication: Issues related to user identity, login flows, API key handling, credential storage, and access token management, unable to sign in selecting wrong authentication path etc..
-            area/security-privacy: Issues concerning vulnerability patching, dependency security, data sanitization, privacy controls, and preventing unauthorized data access.
-            area/extensibility: Issues related to the plugin system, extension APIs, or making the CLI's functionality available in other applications, github actions, ide support etc..
-            area/performance: Issues focused on model performance
-            - Issues with running out of capacity,
-            - 429 errors etc..
-            - could also pertain to latency,
-            - other general software performance like, memory usage, CPU consumption, and algorithmic efficiency.
-            - Switching models from one to the other unexpectedly.

.github/workflows/gemini-scheduled-issue-dedup.yml

@@ -0,0 +1,116 @@
+name: '📋 Gemini Scheduled Issue Deduplication'
+
+on:
+  schedule:
+    - cron: '0 * * * *' # Runs every hour
+  workflow_dispatch:
+
+concurrency:
+  group: '${{ github.workflow }}'
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: 'bash'
+
+jobs:
+  refresh-embeddings:
+    if: |-
+      ${{ vars.TRIAGE_DEDUPLICATE_ISSUES != '' && github.repository == 'google-gemini/gemini-cli' }}
+    permissions:
+      contents: 'read'
+      id-token: 'write' # Required for WIF, see https://docs.github.com/en/actions/how-tos/secure-your-work/security-harden-deployments/oidc-in-google-cloud-platform#adding-permissions-settings
+      issues: 'read'
+      statuses: 'read'
+      packages: 'read'
+    timeout-minutes: 20
+    runs-on: 'ubuntu-latest'
+    steps:
+      - name: 'Checkout'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
+
+      - name: 'Log in to GitHub Container Registry'
+        uses: 'docker/login-action@184bdaa0721073962dff0199f1fb9940f07167d1' # ratchet:docker/login-action@v3
+        with:
+          registry: 'ghcr.io'
+          username: '${{ github.actor }}'
+          password: '${{ secrets.GITHUB_TOKEN }}'
+
+      - name: 'Run Gemini Issue Deduplication Refresh'
+        uses: 'google-github-actions/run-gemini-cli@a3bf79042542528e91937b3a3a6fbc4967ee3c31' # ratchet:google-github-actions/run-gemini-cli@v0
+        id: 'gemini_refresh_embeddings'
+        env:
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          ISSUE_TITLE: '${{ github.event.issue.title }}'
+          ISSUE_BODY: '${{ github.event.issue.body }}'
+          ISSUE_NUMBER: '${{ github.event.issue.number }}'
+          REPOSITORY: '${{ github.repository }}'
+          FIRESTORE_PROJECT: '${{ vars.FIRESTORE_PROJECT }}'
+        with:
+          gcp_workload_identity_provider: '${{ vars.GCP_WIF_PROVIDER }}'
+          gcp_project_id: '${{ vars.GOOGLE_CLOUD_PROJECT }}'
+          gcp_location: '${{ vars.GOOGLE_CLOUD_LOCATION }}'
+          gcp_service_account: '${{ vars.SERVICE_ACCOUNT_EMAIL }}'
+          gemini_api_key: '${{ secrets.GEMINI_API_KEY }}'
+          use_vertex_ai: '${{ vars.GOOGLE_GENAI_USE_VERTEXAI }}'
+          use_gemini_code_assist: '${{ vars.GOOGLE_GENAI_USE_GCA }}'
+          settings: |-
+            {
+              "mcpServers": {
+                "issue_deduplication": {
+                  "command": "docker",
+                  "args": [
+                    "run",
+                    "-i",
+                    "--rm",
+                    "--network", "host",
+                    "-e", "GITHUB_TOKEN",
+                    "-e", "GEMINI_API_KEY",
+                    "-e", "DATABASE_TYPE",
+                    "-e", "FIRESTORE_DATABASE_ID",
+                    "-e", "GCP_PROJECT",
+                    "-e", "GOOGLE_APPLICATION_CREDENTIALS=/app/gcp-credentials.json",
+                    "-v", "${GOOGLE_APPLICATION_CREDENTIALS}:/app/gcp-credentials.json",
+                    "ghcr.io/google-gemini/gemini-cli-issue-triage@sha256:e3de1523f6c83aabb3c54b76d08940a2bf42febcb789dd2da6f95169641f94d3"
+                  ],
+                  "env": {
+                    "GITHUB_TOKEN": "${GITHUB_TOKEN}",
+                    "GEMINI_API_KEY": "${{ secrets.GEMINI_API_KEY }}",
+                    "DATABASE_TYPE":"firestore",
+                    "GCP_PROJECT": "${FIRESTORE_PROJECT}",
+                    "FIRESTORE_DATABASE_ID": "(default)",
+                    "GOOGLE_APPLICATION_CREDENTIALS": "${GOOGLE_APPLICATION_CREDENTIALS}"
+                  },
+                  "enabled": true,
+                  "timeout": 600000
+                }
+              },
+              "maxSessionTurns": 25,
+              "coreTools": [
+                "run_shell_command(echo)"
+              ],
+              "telemetry": {
+                "enabled": true,
+                "target": "gcp"
+              }
+            }
+          prompt: |-
+            ## Role
+
+            You are a database maintenance assistant for a GitHub issue deduplication system.
+
+            ## Goal
+
+            Your sole responsibility is to refresh the embeddings for all open issues in the repository to ensure the deduplication database is up-to-date.
+
+            ## Steps
+
+            1.  **Extract Repository Information:** The repository is ${{ github.repository }}.
+            2.  **Refresh Embeddings:** Call the `refresh` tool with the correct `repo`. Do not use the `force` parameter.
+            3.  **Log Output:** Print the JSON output from the `refresh` tool to the logs.
+
+            ## Guidelines
+
+            - Only use the `refresh` tool.
+            - Do not attempt to find duplicates or modify any issues.
+            - Your only task is to call the `refresh` tool and log its output.

.github/workflows/gemini-scheduled-issue-triage.yml

@@ -1,180 +0,0 @@
-name: Qwen Scheduled Issue Triage
-
-on:
-  schedule:
-    - cron: '0 * * * *' # Runs every hour
-  workflow_dispatch: {}
-
-jobs:
-  triage-issues:
-    timeout-minutes: 10
-    if: ${{ github.repository == 'QwenLM/qwen-code' }}
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-      issues: write
-    steps:
-      - name: Find untriaged issues
-        id: find_issues
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          echo "🔍 Finding issues without labels..."
-          NO_LABEL_ISSUES=$(gh issue list --repo ${{ github.repository }} --search "is:open is:issue no:label" --json number,title,body)
-
-          echo "🏷️ Finding issues that need triage..."
-          NEED_TRIAGE_ISSUES=$(gh issue list --repo ${{ github.repository }} --search "is:open is:issue label:\"status/need-triage\"" --json number,title,body)
-
-          echo "🔄 Merging and deduplicating issues..."
-          ISSUES=$(echo "$NO_LABEL_ISSUES" "$NEED_TRIAGE_ISSUES" | jq -c -s 'add | unique_by(.number)')
-
-          echo "📝 Setting output for GitHub Actions..."
-          echo "issues_to_triage=$ISSUES" >> "$GITHUB_OUTPUT"
-
-          echo "✅ Found $(echo "$ISSUES" | jq 'length') issues to triage! 🎯"
-
-      - name: Run Qwen Issue Triage
-        if: steps.find_issues.outputs.issues_to_triage != '[]'
-        uses: QwenLM/qwen-code-action@5fd6818d04d64e87d255ee4d5f77995e32fbf4c2
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          ISSUES_TO_TRIAGE: ${{ steps.find_issues.outputs.issues_to_triage }}
-          REPOSITORY: ${{ github.repository }}
-        with:
-          version: 0.0.4
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          OPENAI_BASE_URL: ${{ secrets.OPENAI_BASE_URL }}
-          OPENAI_MODEL: ${{ secrets.OPENAI_MODEL }}
-          settings_json: |
-            {
-              "coreTools": [
-                "run_shell_command(echo)",
-                "run_shell_command(gh label list)",
-                "run_shell_command(gh issue edit)",
-                "run_shell_command(gh issue list)",
-                "run_shell_command(gh issue view)"
-              ],
-              "sandbox": false
-            }
-          prompt: |
-            You are an issue triage assistant. Analyze the current GitHub issues apply the most appropriate existing labels. 
-            Steps:
-            1. Run: `gh label list --repo ${{ github.repository }} --limit 100` to get all available labels.
-            2. Check environment variable for issues to triage: $ISSUES_TO_TRIAGE (JSON array of issues)
-            3. Review the issue title, body and any comments provided in the environment variables.
-            4. Ignore any existing priorities or tags on the issue.
-            5. Select the most relevant labels from the existing labels, focusing on kind/*, area/*, sub-area/* and priority/*. 
-            6. Get the list of labels already on the issue using `gh issue view ISSUE_NUMBER --repo ${{ github.repository }} --json labels -t '{{range .labels}}{{.name}}{{"\n"}}{{end}}'
-            7. For area/* and kind/* limit yourself to only the single most applicable label in each case. 
-            8. Give me a single short paragraph about why you are selecting each label in the process. use the format Issue ID: , Title, Label applied:, Label removed, ovearll explanation
-            9. Parse the JSON array from step 2 and for EACH INDIVIDUAL issue, apply appropriate labels using separate commands:
-              - `gh issue edit ISSUE_NUMBER --repo ${{ github.repository }} --add-label "label1"`
-              - `gh issue edit ISSUE_NUMBER --repo ${{ github.repository }} --add-label "label2"`
-              - Continue for each label separately
-              - IMPORTANT: Label each issue individually, one command per issue, one label at a time if needed.
-              - Make sure after you apply labels there is only one area/* and one kind/* label per issue.  
-              - To do this look for labels found in step 6 that no longer apply remove them one at a time using 
-              - `gh issue edit ISSUE_NUMBER --repo ${{ github.repository }} --remove-label "label-name1"`
-              - `gh issue edit ISSUE_NUMBER --repo ${{ github.repository }} --remove-label "label-name2"`
-              - IMPORTANT: Remove each label one at a time, one command per issue if needed.
-            10. For each issue please check if CLI version is present, this is usually in the output of the /about command and will look like 0.1.5 
-              - Anything more than 6 versions older than the most recent should add the status/need-retesting label
-            11. If you see that the issue doesn’t look like it has sufficient information recommend the status/need-information label
-              - After applying appropriate labels to an issue, remove the "status/need-triage" label if present: `gh issue edit ISSUE_NUMBER --repo ${{ github.repository }} --remove-label "status/need-triage"`
-              - Execute one `gh issue edit` command per issue, wait for success before proceeding to the next
-            Process each issue sequentially and confirm each labeling operation before moving to the next issue.
-            Guidelines:
-              - Only use labels that already exist in the repository.
-              - Do not add comments or modify the issue content.
-              - Do not remove labels titled help wanted or good first issue.
-              - Triage only the current issue.
-              - Apply only one area/ label
-              - Apply only one kind/ label (Do not apply kind/duplicate or kind/parent-issue) 
-              - Apply all applicable sub-area/* and priority/* labels based on the issue content. It's ok to have multiple of these.
-              - Once you categorize the issue if it needs information bump down the priority by 1 eg.. a p0 would become a p1 a p1 would become a p2. P2 and P3 can stay as is in this scenario.
-            Categorization Guidelines: 
-            P0: Critical / Blocker
-              - A P0 bug is a catastrophic failure that demands immediate attention. It represents a complete showstopper for a significant portion of users or for the development process itself.
-              Impact:
-              - Blocks development or testing for the entire team.
-              - Major security vulnerability that could compromise user data or system integrity.
-              - Causes data loss or corruption with no workaround.
-              - Crashes the application or makes a core feature completely unusable for all or most users in a production environment. Will it cause severe quality degration? 
-              - Is it preventing contributors from contributing to the repository or is it a release blocker?
-              Qualifier: Is the main function of the software broken?
-              Example: The gemini auth login command fails with an unrecoverable error, preventing any user from authenticating and using the rest of the CLI.
-            P1: High
-              - A P1 bug is a serious issue that significantly degrades the user experience or impacts a core feature. While not a complete blocker, it's a major problem that needs a fast resolution. 
-              - Feature requests are almost never P1.
-              Impact:
-              - A core feature is broken or behaving incorrectly for a large number of users or large number of use cases.
-              - Review the bug details and comments to try figure out if this issue affects a large set of use cases or if it's a narrow set of use cases.
-              - Severe performance degradation making the application frustratingly slow.
-              - No straightforward workaround exists, or the workaround is difficult and non-obvious.
-              Qualifier: Is a key feature unusable or giving very wrong results?
-              Example: The gemini -p "..." command consistently returns a malformed JSON response or an empty result, making the CLI's primary generation feature unreliable.
-            P2: Medium
-              - A P2 bug is a moderately impactful issue. It's a noticeable problem but doesn't prevent the use of the software's main functionality.
-              Impact:
-              - Affects a non-critical feature or a smaller, specific subset of users.
-              - An inconvenient but functional workaround is available and easy to execute.
-              - Noticeable UI/UX problems that don't break functionality but look unprofessional (e.g., elements are misaligned or overlapping).
-              Qualifier: Is it an annoying but non-blocking problem?
-              Example: An error message is unclear or contains a typo, causing user confusion but not halting their workflow.
-            P3: Low
-              - A P3 bug is a minor, low-impact issue that is trivial or cosmetic. It has little to no effect on the overall functionality of the application.
-              Impact:
-              - Minor cosmetic issues like color inconsistencies, typos in documentation, or slight alignment problems on a non-critical page.
-              - An edge-case bug that is very difficult to reproduce and affects a tiny fraction of users.
-              Qualifier: Is it a "nice-to-fix" issue?
-              Example: Spelling mistakes etc.
-            Additional Context: 
-              - If users are talking about issues where the model gets downgraded from pro to flash then i want you to categorize that as a performance issue
-              - This product is designed to use different models eg.. using pro, downgrading to flash etc. 
-              - When users report that they dont expect the model to change those would be categorized as feature requests.
-            Definition of Areas
-            area/ux: 
-              - Issues concerning user-facing elements like command usability, interactive features, help docs, and perceived performance.
-              - I am seeing my screen flicker when using Gemini CLI 
-              - I am seeing the output malformed 
-              - Theme changes aren't taking effect 
-              - My keyboard inputs arent' being recognzied
-            area/platform: 
-              - Issues related to installation, packaging, OS compatibility (Windows, macOS, Linux), and the underlying CLI framework.
-            area/background: Issues related to long-running background tasks, daemons, and autonomous or proactive agent features.
-            area/models: 
-              - i am not getting a response that is reasonable or expected. this can include things like
-              - I am calling a tool and the tool is not performing as expected.
-              - i am expecting a tool to be called and it is not getting called ,
-              - Including experience when using
-              - built-in tools (e.g., web search, code interpreter, read file, writefile, etc..),
-              - Function calling issues should be under this area
-              - i am getting responses from the model that are malformed.
-              - Issues concerning Gemini quality of response and inference,
-              - Issues talking about unnecessary token consumption.
-              - Issues talking about Model getting stuck in a loop be watchful as this could be the root cause for issues that otherwise seem like model performance issues.
-              - Memory compression
-              - unexpected responses,
-              - poor quality of generated code
-            area/tools: 
-              - These are primarily issues related to Model Context Protocol 
-              - These are issues that mention MCP support 
-              - feature requests asking for support for new tools. 
-            area/core: 
-              - Issues with fundamental components like command parsing, configuration management, session state, and the main API client logic. Introducing multi-modality
-            area/contribution: 
-              - Issues related to improving the developer contribution experience, such as CI/CD pipelines, build scripts, and test automation infrastructure.
-            area/authentication: 
-              -  Issues related to user identity, login flows, API key handling, credential storage, and access token management, unable to sign in selecting wrong authentication path etc..
-            area/security-privacy: 
-              - Issues concerning vulnerability patching, dependency security, data sanitization, privacy controls, and preventing unauthorized data access.
-            area/extensibility: 
-              - Issues related to the plugin system, extension APIs, or making the CLI's functionality available in other applications, github actions, ide support etc..
-            area/performance: 
-              - Issues focused on model performance
-              - Issues with running out of capacity,
-              - 429 errors etc..
-              - could also pertain to latency,
-              - other general software performance like, memory usage, CPU consumption, and algorithmic efficiency.
-              - Switching models from one to the other unexpectedly.

.github/workflows/gemini-scheduled-pr-triage.yml

@@ -1,29 +1,30 @@
-name: Qwen Scheduled PR Triage 🚀
+name: 'Qwen Scheduled PR Triage 🚀'
 
 on:
   schedule:
     - cron: '*/15 * * * *' # Runs every 15 minutes
-  workflow_dispatch: {}
+  workflow_dispatch:
 
 jobs:
   audit-prs:
     timeout-minutes: 15
-    if: ${{ github.repository == 'QwenLM/qwen-code' }}
+    if: |-
+      ${{ github.repository == 'QwenLM/qwen-code' }}
     permissions:
-      contents: read
-      id-token: write
-      issues: write
-      pull-requests: write
-    runs-on: ubuntu-latest
+      contents: 'read'
+      id-token: 'write'
+      issues: 'write'
+      pull-requests: 'write'
+    runs-on: 'ubuntu-latest'
     outputs:
-      prs_needing_comment: ${{ steps.run_triage.outputs.prs_needing_comment }}
+      prs_needing_comment: '${{ steps.run_triage.outputs.prs_needing_comment }}'
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - name: 'Checkout'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
 
-      - name: Run PR Triage Script
-        id: run_triage
+      - name: 'Run PR Triage Script'
+        id: 'run_triage'
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GITHUB_REPOSITORY: ${{ github.repository }}
-        run: ./.github/scripts/pr-triage.sh
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          GITHUB_REPOSITORY: '${{ github.repository }}'
+        run: './.github/scripts/pr-triage.sh'

.github/workflows/gemini-self-assign-issue.yml

@@ -0,0 +1,99 @@
+name: 'Assign Issue on Comment'
+
+on:
+  issue_comment:
+    types:
+      - 'created'
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.event.issue.number }}'
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: 'bash'
+
+permissions:
+  contents: 'read'
+  id-token: 'write'
+  issues: 'write'
+  statuses: 'write'
+  packages: 'read'
+
+jobs:
+  self-assign-issue:
+    if: |-
+      github.repository == 'google-gemini/gemini-cli' &&
+      github.event_name == 'issue_comment' &&
+      contains(github.event.comment.body, '/assign')
+    runs-on: 'ubuntu-latest'
+    steps:
+      - name: 'Generate GitHub App Token'
+        id: 'generate_token'
+        uses: 'actions/create-github-app-token@a8d616148505b5069dccd32f177bb87d7f39123b'
+        with:
+          app-id: '${{ secrets.APP_ID }}'
+          private-key: '${{ secrets.PRIVATE_KEY }}'
+          # Add 'assignments' write permission
+          permission-issues: 'write'
+
+      - name: 'Assign issue to user'
+        uses: 'actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea'
+        with:
+          github-token: '${{ steps.generate_token.outputs.token }}'
+          script: |
+            const issueNumber = context.issue.number;
+            const commenter = context.actor;
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
+            const MAX_ISSUES_ASSIGNED = 3;
+
+            // Search for open issues already assigned to the commenter in this repo
+            const { data: assignedIssues } = await github.rest.search.issuesAndPullRequests({
+              q: `is:issue repo:${owner}/${repo} assignee:${commenter} is:open`,
+              advanced_search: true
+            });
+
+            if (assignedIssues.total_count >= MAX_ISSUES_ASSIGNED) {
+              await github.rest.issues.createComment({
+                owner: owner,
+                repo: repo,
+                issue_number: issueNumber,
+                body: `👋 @${commenter}! You currently have ${assignedIssues.total_count} issues assigned to you. We have a ${MAX_ISSUES_ASSIGNED} max issues assigned at once policy. Once you close out an existing issue it will open up space to take another. You can also unassign yourself from an existing issue but please work on a hand-off if someone is expecting work on that issue.`
+              });
+              return; // exit
+            }
+
+            // Check if the issue is already assigned
+            const issue = await github.rest.issues.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issueNumber,
+            });
+
+            if (issue.data.assignees.length > 0) {
+              // Comment that it's already assigned
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                body: `@${commenter} Thanks for taking interest but this issue is already assigned. We'd still love to have you contribute. Check out our [Help Wanted](https://github.com/google-gemini/gemini-cli/issues?q=is%3Aissue%20state%3Aopen%20label%3A%22help%20wanted%22) list for issues where we need some extra attention.`
+              });
+              return;
+            }
+
+            // If not taken, assign the user who commented
+            await github.rest.issues.addAssignees({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issueNumber,
+              assignees: [commenter]
+            });
+
+            // Post a comment to confirm assignment
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issueNumber,
+              body: `👋 @${commenter}, you've been assigned to this issue! Thank you for taking the time to contribute. Make sure to check out our [contributing guidelines](https://github.com/google-gemini/gemini-cli/blob/main/CONTRIBUTING.md).`
+            });

.github/workflows/no-response.yml

@@ -1,32 +1,33 @@
-name: No Response
+name: 'No Response'
 
 # Run as a daily cron at 1:45 AM
 on:
   schedule:
     - cron: '45 1 * * *'
-  workflow_dispatch: {}
+  workflow_dispatch:
 
 jobs:
   no-response:
-    runs-on: ubuntu-latest
-    if: ${{ github.repository == 'google-gemini/gemini-cli' }}
+    runs-on: 'ubuntu-latest'
+    if: |-
+      ${{ github.repository == 'google-gemini/gemini-cli' }}
     permissions:
-      issues: write
-      pull-requests: write
+      issues: 'write'
+      pull-requests: 'write'
     concurrency:
-      group: ${{ github.workflow }}-no-response
+      group: '${{ github.workflow }}-no-response'
       cancel-in-progress: true
     steps:
-      - uses: actions/stale@5bef64f19d7facfb25b37b414482c7164d639639
+      - uses: 'actions/stale@5bef64f19d7facfb25b37b414482c7164d639639' # ratchet:actions/stale@v9
         with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          repo-token: '${{ secrets.GITHUB_TOKEN }}'
           days-before-stale: -1
           days-before-close: 14
           stale-issue-label: 'status/need-information'
-          close-issue-message: >
+          close-issue-message: >-
             This issue was marked as needing more information and has not received a response in 14 days.
             Closing it for now. If you still face this problem, feel free to reopen with more details. Thank you!
           stale-pr-label: 'status/need-information'
-          close-pr-message: >
+          close-pr-message: >-
             This pull request was marked as needing more information and has had no updates in 14 days.
             Closing it for now. You are welcome to reopen with the required info. Thanks for contributing!

.github/workflows/qwen-automated-issue-triage.yml

@@ -0,0 +1,203 @@
+name: 'Qwen Automated Issue Triage'
+
+on:
+  issues:
+    types:
+      - 'opened'
+      - 'reopened'
+  issue_comment:
+    types:
+      - 'created'
+  workflow_dispatch:
+    inputs:
+      issue_number:
+        description: 'issue number to triage'
+        required: true
+        type: 'number'
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.event.issue.number || github.event.inputs.issue_number }}'
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: 'bash'
+
+permissions:
+  contents: 'read'
+  id-token: 'write'
+  issues: 'write'
+  statuses: 'write'
+  packages: 'read'
+  actions: 'write' # Required for cancelling a workflow run
+
+jobs:
+  triage-issue:
+    timeout-minutes: 5
+    if: |-
+      ${{ github.repository == 'QwenLM/qwen-code' }}
+    runs-on: 'ubuntu-latest'
+    steps:
+      - name: 'Run Qwen Issue Analysis'
+        uses: 'QwenLM/qwen-code-action@5fd6818d04d64e87d255ee4d5f77995e32fbf4c2'
+        id: 'qwen_issue_analysis'
+        env:
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          ISSUE_TITLE: '${{ github.event.issue.title }}'
+          ISSUE_BODY: '${{ github.event.issue.body }}'
+          ISSUE_NUMBER: '${{ github.event.issue.number }}'
+          REPOSITORY: '${{ github.repository }}'
+        with:
+          OPENAI_API_KEY: '${{ secrets.OPENAI_API_KEY }}'
+          OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'
+          OPENAI_MODEL: '${{ secrets.OPENAI_MODEL }}'
+          settings_json: |-
+            {
+              "maxSessionTurns": 25,
+              "coreTools": [
+                "run_shell_command"
+              ],
+              "sandbox": false
+            }
+          prompt: |-
+            ## Role
+
+            You are an issue triage assistant. Analyze the current GitHub issue
+            and identify the most appropriate existing labels by only using the provided data. Use the available
+            tools to gather information; do not ask for information to be
+            provided. Do not remove the following labels titled maintainer,  help wanted or good first issue.
+
+            ## Steps
+
+            1. Run: `gh label list --repo ${{ github.repository }} --limit 100` to get all available labels.
+            2. Use shell command `echo` to check the issue title and body provided in the environment variables: "${ISSUE_TITLE}" and "${ISSUE_BODY}".
+            3. Ignore any existing priorities or tags on the issue. Just report your findings.
+            4. Select the most relevant labels from the existing labels, focusing on type/*, category/*, scope/*, status/* and priority/*. For category/* and type/* limit yourself to only the single most applicable label in each case.
+            6. Apply the selected labels to this issue using: `gh issue edit ${{ github.event.issue.number }} --repo ${{ github.repository }} --add-label "label1,label2"`.
+            7. For each issue please check if CLI version is present, this is usually in the output of the /about command  and will look like 0.1.5 for anything more than 6 versions older than the most recent should add the status/need-retesting label.
+            8. If you see that the issue doesn't look like it has sufficient information recommend the status/need-information label.
+            9. Use Category and Scope definitions mentioned below to help you narrow down issues.
+
+            ## Guidelines
+
+            - Only use labels that already exist in the repository
+            - Do not add comments or modify the issue content
+            - Triage only the current issue
+            - Identify only one category/ label
+            - Identify only one type/ label
+            - Identify all applicable scope/*, status/* and priority/* labels based on the issue content. It's ok to have multiple of these
+            - Once you categorize the issue if it needs information bump down the priority by 1 eg.. a p0 would become a p1 a p1 would become a p2. P2 and P3 can stay as is in this scenario
+            - Reference all shell variables as "${VAR}" (with quotes and braces)
+            - Output only valid JSON format
+            - Do not include any explanation or additional text, just the JSON
+
+            Categorization Guidelines:
+            P0: Critical / Blocker
+            - A P0 bug is a catastrophic failure that demands immediate attention.
+            - To be a P0 it means almost all users are running into this issue and it is blocking users from being able to use the product.
+            - You would see this in the form of many comments from different developers on the bug.
+            - It represents a complete showstopper for a significant portion of users or for the development process itself.
+            Impact:
+            - Blocks development or testing for the entire team.
+            - Major security vulnerability that could compromise user data or system integrity.
+            - Causes data loss or corruption with no workaround.
+            - Crashes the application or makes a core feature completely unusable for all or most users in a production environment. Will it cause severe quality degration? Is it preventing contributors from contributing to the repository or is it a release blocker?
+            Qualifier: Is the main function of the software broken?
+            Example: The qwen auth login command fails with an unrecoverable error, preventing any user from authenticating and using the rest of the CLI.
+            P1: High
+            - A P1 bug is a serious issue that significantly degrades the user experience or impacts a core feature.
+            - While not a complete blocker, it's a major problem that needs a fast resolution. Feature requests are almost never P1.
+            - Once again this would be affecting many users.
+            - You would see this in the form of comments from different developers on the bug.
+            Impact:
+            - A core feature is broken or behaving incorrectly for a large number of users or large number of use cases.
+            - Review the bug details and comments to try figure out if this issue affects a large set of use cases or if it's a narrow set of use cases.
+            - Severe performance degradation making the application frustratingly slow.
+            - No straightforward workaround exists, or the workaround is difficult and non-obvious.
+            Qualifier: Is a key feature unusable or giving very wrong results?
+            Example: Qwen Code enters a loop when making read-many-files tool call. I am unable to break out of the loop and qwen doesn't follow instructions subsequently.
+            P2: Medium
+            - A P2 bug is a moderately impactful issue. It's a noticeable problem but doesn't prevent the use of the software's main functionality.
+            Impact:
+            - Affects a non-critical feature or a smaller, specific subset of users.
+            - An inconvenient but functional workaround is available and easy to execute.
+            - Noticeable UI/UX problems that don't break functionality but look unprofessional (e.g., elements are misaligned or overlapping).
+            Qualifier: Is it an annoying but non-blocking problem?
+            Example: An error message is unclear or contains a typo, causing user confusion but not halting their workflow.
+            P3: Low
+            - A P3 bug is a minor, low-impact issue that is trivial or cosmetic. It has little to no effect on the overall functionality of the application.
+            Impact:
+            - Minor cosmetic issues like color inconsistencies, typos in documentation, or slight alignment problems on a non-critical page.
+            - An edge-case bug that is very difficult to reproduce and affects a tiny fraction of users.
+            Qualifier: Is it a "nice-to-fix" issue?
+            Example: Spelling mistakes etc.
+            Things you should know:
+            - If users are talking about issues where the model gets downgraded from pro to flash then i want you to categorize that as a performance issue
+            - This product is designed to use different models eg.. using pro, downgrading to flash etc. when users report that they dont expect the model to change those would be categorized as feature requests.
+            Definition of Categories and Scopes
+
+            category/cli: Command line interface and interaction
+            - Issues with interactive CLI features, command parsing, keyboard shortcuts
+            - Related scopes: scope/commands, scope/interactive, scope/non-interactive, scope/keybindings
+
+            category/core: Core engine and logic
+            - Issues with fundamental components, content generation, session management
+            - Related scopes: scope/content-generation, scope/token-management, scope/session-management, scope/model-switching
+
+            category/ui: User interface and display
+            - Issues with themes, UI components, rendering, markdown display
+            - Related scopes: scope/themes, scope/components, scope/rendering, scope/markdown
+
+            category/authentication: Authentication and authorization
+            - Issues with login flows, API keys, OAuth, credential storage
+            - Related scopes: scope/oauth, scope/api-keys, scope/token-storage
+
+            category/tools: Tool integration and execution
+            - Issues with MCP, shell execution, file operations, web search, memory, git integration
+            - Related scopes: scope/mcp, scope/shell, scope/file-operations, scope/web-search, scope/memory, scope/git
+
+            category/configuration: Configuration management
+            - Issues with settings, extensions, trusted folders, sandbox configuration
+            - Related scopes: scope/settings, scope/extensions, scope/trusted-folders, scope/sandbox
+
+            category/integration: External integrations
+            - Issues with IDE integration, VSCode extension, Zed integration, GitHub Actions
+            - Related scopes: scope/ide, scope/vscode, scope/zed, scope/github-actions
+
+            category/platform: Platform compatibility
+            - Issues with installation, OS compatibility, packaging
+            - Related scopes: scope/installation, scope/macos, scope/windows, scope/linux, scope/packaging
+
+            category/performance: Performance and optimization
+            - Issues with latency, memory usage, model performance, caching
+            - Related scopes: scope/latency, scope/memory-usage, scope/model-performance, scope/caching
+
+            category/security: Security and privacy
+            - Issues with data privacy, credential security, vulnerabilities
+            - Related scopes: scope/data-privacy, scope/credential-security, scope/vulnerability
+
+            category/telemetry: Telemetry and analytics
+            - Issues with metrics collection, logging, analytics
+            - Related scopes: scope/metrics, scope/logging, scope/analytics
+
+            category/development: Development experience
+            - Issues with build system, testing, CI/CD, documentation
+            - Related scopes: scope/build-system, scope/testing, scope/ci-cd, scope/documentation
+
+      - name: 'Post Issue Analysis Failure Comment'
+        if: |-
+          ${{ failure() && steps.qwen_issue_analysis.outcome == 'failure' }}
+        uses: 'actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea' # ratchet:actions/github-script@v7
+        env:
+          ISSUE_NUMBER: '${{ github.event.issue.number }}'
+          REPOSITORY: '${{ github.repository }}'
+          RUN_URL: '${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}'
+        with:
+          github-token: '${{ secrets.GITHUB_TOKEN }}'
+          script: |-
+            github.rest.issues.createComment({
+              owner: process.env.REPOSITORY.split('/')[0],
+              repo: process.env.REPOSITORY.split('/')[1],
+              issue_number: parseInt(process.env.ISSUE_NUMBER),
+              body: 'There is a problem with the Qwen Code issue analysis. Please check the [action logs](${process.env.RUN_URL}) for details.'
+            })

.github/workflows/qwen-code-pr-review.yml

@@ -1,24 +1,28 @@
-name: 🧐 Qwen Pull Request Review
+name: '🧐 Qwen Pull Request Review'
 
 on:
-  pull_request:
-    types: [opened]
+  pull_request_target:
+    types: ['opened']
   pull_request_review_comment:
-    types: [created]
+    types: ['created']
   pull_request_review:
-    types: [submitted]
+    types: ['submitted']
   workflow_dispatch:
     inputs:
       pr_number:
         description: 'PR number to review'
         required: true
-        type: number
+        type: 'number'
 
 jobs:
   review-pr:
-    if: >
+    if: |-
       github.event_name == 'workflow_dispatch' ||
-      (github.event_name == 'pull_request' && github.event.action == 'opened') ||
+      (github.event_name == 'pull_request_target' &&
+       github.event.action == 'opened' &&
+       (github.event.pull_request.author_association == 'OWNER' ||
+        github.event.pull_request.author_association == 'MEMBER' ||
+        github.event.pull_request.author_association == 'COLLABORATOR')) ||
       (github.event_name == 'issue_comment' &&
         github.event.issue.pull_request &&
         contains(github.event.comment.body, '@qwen /review') &&
@@ -36,25 +40,26 @@ jobs:
          github.event.review.author_association == 'MEMBER' ||
          github.event.review.author_association == 'COLLABORATOR'))
     timeout-minutes: 15
-    runs-on: ubuntu-latest
+    runs-on: 'ubuntu-latest'
     permissions:
-      contents: read
-      id-token: write
-      pull-requests: write
-      issues: write
+      contents: 'read'
+      id-token: 'write'
+      pull-requests: 'write'
+      issues: 'write'
     steps:
-      - name: Checkout PR code
-        uses: actions/checkout@v4
+      - name: 'Checkout PR code'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
         with:
-          token: ${{ secrets.GITHUB_TOKEN }}
+          token: '${{ secrets.GITHUB_TOKEN }}'
           fetch-depth: 0
 
-      - name: Get PR details (pull_request & workflow_dispatch)
-        id: get_pr
-        if: github.event_name == 'pull_request' || github.event_name == 'workflow_dispatch'
+      - name: 'Get PR details (pull_request_target & workflow_dispatch)'
+        id: 'get_pr'
+        if: |-
+          ${{ github.event_name == 'pull_request_target' || github.event_name == 'workflow_dispatch' }}
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+        run: |-
           if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
             PR_NUMBER=${{ github.event.inputs.pr_number }}
           else
@@ -70,13 +75,14 @@ jobs:
           echo "$CHANGED_FILES" >> "$GITHUB_OUTPUT"
           echo "EOF" >> "$GITHUB_OUTPUT"
 
-      - name: Get PR details (issue_comment)
-        id: get_pr_comment
-        if: github.event_name == 'issue_comment'
+      - name: 'Get PR details (issue_comment)'
+        id: 'get_pr_comment'
+        if: |-
+          ${{ github.event_name == 'issue_comment' }}
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          COMMENT_BODY: ${{ github.event.comment.body }}
-        run: |
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          COMMENT_BODY: '${{ github.event.comment.body }}'
+        run: |-
           PR_NUMBER=${{ github.event.issue.number }}
           echo "pr_number=$PR_NUMBER" >> "$GITHUB_OUTPUT"
           # Extract additional instructions from comment
@@ -91,35 +97,28 @@ jobs:
           echo "$CHANGED_FILES" >> "$GITHUB_OUTPUT"
           echo "EOF" >> "$GITHUB_OUTPUT"
 
-      - name: Run Qwen PR Review
-        uses: QwenLM/qwen-code-action@5fd6818d04d64e87d255ee4d5f77995e32fbf4c2
+      - name: 'Run Qwen PR Review'
+        uses: 'QwenLM/qwen-code-action@5fd6818d04d64e87d255ee4d5f77995e32fbf4c2'
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR_NUMBER: ${{ steps.get_pr.outputs.pr_number || steps.get_pr_comment.outputs.pr_number }}
-          PR_DATA: ${{ steps.get_pr.outputs.pr_data || steps.get_pr_comment.outputs.pr_data }}
-          CHANGED_FILES: ${{ steps.get_pr.outputs.changed_files || steps.get_pr_comment.outputs.changed_files }}
-          ADDITIONAL_INSTRUCTIONS: ${{ steps.get_pr.outputs.additional_instructions || steps.get_pr_comment.outputs.additional_instructions }}
-          REPOSITORY: ${{ github.repository }}
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          PR_NUMBER: '${{ steps.get_pr.outputs.pr_number || steps.get_pr_comment.outputs.pr_number }}'
+          PR_DATA: '${{ steps.get_pr.outputs.pr_data || steps.get_pr_comment.outputs.pr_data }}'
+          CHANGED_FILES: '${{ steps.get_pr.outputs.changed_files || steps.get_pr_comment.outputs.changed_files }}'
+          ADDITIONAL_INSTRUCTIONS: '${{ steps.get_pr.outputs.additional_instructions || steps.get_pr_comment.outputs.additional_instructions }}'
+          REPOSITORY: '${{ github.repository }}'
         with:
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          OPENAI_BASE_URL: ${{ secrets.OPENAI_BASE_URL }}
-          OPENAI_MODEL: ${{ secrets.OPENAI_MODEL }}
-          settings_json: |
+          OPENAI_API_KEY: '${{ secrets.OPENAI_API_KEY }}'
+          OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'
+          OPENAI_MODEL: '${{ secrets.OPENAI_MODEL }}'
+          settings_json: |-
             {
               "coreTools": [
-                "run_shell_command(echo)",
-                "run_shell_command(gh pr view)",
-                "run_shell_command(gh pr diff)",
-                "run_shell_command(gh pr comment)",
-                "run_shell_command(cat)",
-                "run_shell_command(head)",
-                "run_shell_command(tail)",
-                "run_shell_command(grep)",
+                "run_shell_command",
                 "write_file"
               ],
               "sandbox": false
             }
-          prompt: |
+          prompt: |-
             You are an expert code reviewer. You have access to shell commands to gather PR information and perform the review.
 
             IMPORTANT: Use the available shell commands to gather information. Do not ask for information to be provided.

.github/workflows/qwen-scheduled-issue-triage.yml

@@ -0,0 +1,213 @@
+name: 'Qwen Scheduled Issue Triage'
+
+on:
+  schedule:
+    - cron: '0 * * * *' # Runs every hour
+  workflow_dispatch:
+
+concurrency:
+  group: '${{ github.workflow }}'
+  cancel-in-progress: true
+
+defaults:
+  run:
+    shell: 'bash'
+
+permissions:
+  id-token: 'write'
+  issues: 'write'
+
+jobs:
+  triage-issues:
+    timeout-minutes: 10
+    if: |-
+      ${{ github.repository == 'QwenLM/qwen-code' }}
+    runs-on: 'ubuntu-latest'
+    permissions:
+      contents: 'read'
+      id-token: 'write'
+      issues: 'write'
+    steps:
+      - name: 'Find untriaged issues'
+        id: 'find_issues'
+        env:
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          GITHUB_REPOSITORY: '${{ github.repository }}'
+        run: |-
+          echo "🔍 Finding issues without labels..."
+          NO_LABEL_ISSUES=$(gh issue list --repo ${{ github.repository }} --search "is:open is:issue no:label" --json number,title,body)
+
+          echo '🔍 Finding issues without labels...'
+          NO_LABEL_ISSUES="$(gh issue list --repo "${GITHUB_REPOSITORY}" \
+            --search 'is:open is:issue no:label' --json number,title,body)"
+
+          echo '🏷️ Finding issues that need triage...'
+          NEED_TRIAGE_ISSUES="$(gh issue list --repo "${GITHUB_REPOSITORY}" \
+            --search "is:open is:issue label:\"status/need-triage\""  --limit 1000 --json number,title,body)"
+
+          echo '🔄 Merging and deduplicating issues...'
+          ISSUES="$(echo "${NO_LABEL_ISSUES}" "${NEED_TRIAGE_ISSUES}" | jq -c -s 'add | unique_by(.number)')"
+
+          echo '📝 Setting output for GitHub Actions...'
+          echo "issues_to_triage=${ISSUES}" >> "${GITHUB_OUTPUT}"
+
+      - name: 'Run Qwen Issue Triage'
+        if: |-
+          ${{ steps.find_issues.outputs.issues_to_triage != '[]' }}
+        uses: 'QwenLM/qwen-code-action@5fd6818d04d64e87d255ee4d5f77995e32fbf4c2'
+        env:
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          ISSUES_TO_TRIAGE: '${{ steps.find_issues.outputs.issues_to_triage }}'
+          REPOSITORY: '${{ github.repository }}'
+        with:
+          OPENAI_API_KEY: '${{ secrets.OPENAI_API_KEY }}'
+          OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'
+          OPENAI_MODEL: '${{ secrets.OPENAI_MODEL }}'
+          settings_json: |-
+            {
+              "maxSessionTurns": 25,
+              "coreTools": [
+                "run_shell_command(echo)"
+              ],
+              "sandbox": false
+            }
+          prompt: |-
+            ## Role
+
+            You are an issue triage assistant. Analyze issues and identify
+            appropriate labels. Use the available tools to gather information;
+            do not ask for information to be provided.
+
+            ## Steps
+
+            1. Run: `gh label list --repo ${{ github.repository }} --limit 100` to get all available labels.
+            2. Use shell command `echo` to check environment variable for issues to triage: $ISSUES_TO_TRIAGE (JSON array of issues)
+            3. Review the issue title, body and any comments provided in the environment variables.
+            4. Ignore any existing priorities or tags on the issue.
+            5. Select the most relevant labels from the existing labels, focusing on type/*, category/*, scope/*, status/* and priority/*.
+            6. Get the list of labels already on the issue using `gh issue view ISSUE_NUMBER --repo ${{ github.repository }} --json labels -t '{{range .labels}}{{.name}}{{"\n"}}{{end}}'
+            7. For category/* and type/* limit yourself to only the single most applicable label in each case.
+            8. Give me a single short paragraph about why you are selecting each label in the process. use the format Issue ID: , Title, Label applied:, Label removed, ovearll explanation
+            9. Parse the JSON array from step 2 and for EACH INDIVIDUAL issue, apply appropriate labels using separate commands:
+              - `gh issue edit ISSUE_NUMBER --repo ${{ github.repository }} --add-label "label1"`
+              - `gh issue edit ISSUE_NUMBER --repo ${{ github.repository }} --add-label "label2"`
+              - Continue for each label separately
+              - IMPORTANT: Label each issue individually, one command per issue, one label at a time if needed.
+              - Make sure after you apply labels there is only one category/* and one type/* label per issue.
+              - To do this look for labels found in step 6 that no longer apply remove them one at a time using
+              - `gh issue edit ISSUE_NUMBER --repo ${{ github.repository }} --remove-label "label-name1"`
+              - `gh issue edit ISSUE_NUMBER --repo ${{ github.repository }} --remove-label "label-name2"`
+              - IMPORTANT: Remove each label one at a time, one command per issue if needed.
+            10. For each issue please check if CLI version is present, this is usually in the output of the /about command and will look like 0.1.5
+              - Anything more than 6 versions older than the most recent should add the status/need-retesting label
+            11. If you see that the issue doesn't look like it has sufficient information recommend the status/need-information label
+              - After applying appropriate labels to an issue, remove the "status/need-triage" label if present: `gh issue edit ISSUE_NUMBER --repo ${{ github.repository }} --remove-label "status/need-triage"`
+              - Execute one `gh issue edit` command per issue, wait for success before proceeding to the next
+            Process each issue sequentially and confirm each labeling operation before moving to the next issue.
+
+            ## Guidelines
+
+            - Output only valid JSON format
+            - Do not include any explanation or additional text, just the JSON
+            - Only use labels that already exist in the repository.
+              - Do not add comments or modify the issue content.
+              - Do not remove the following labels maintainer, help wanted or good first issue.
+              - Triage only the current issue.
+              - Identify only one category/ label
+              - Identify only one type/ label (Do not apply type/duplicate or type/parent-issue)
+              - Identify all applicable scope/*, status/* and priority/* labels based on the issue content. It's ok to have multiple of these.
+              - Once you categorize the issue if it needs information bump down the priority by 1 eg.. a p0 would become a p1 a p1 would become a p2. P2 and P3 can stay as is in this scenario.
+            Categorization Guidelines:
+            P0: Critical / Blocker
+              - A P0 bug is a catastrophic failure that demands immediate attention.
+              - To be a P0 it means almost all users are running into this issue and it is blocking users from being able to use the product.
+              - You would see this in the form of many comments from different developers on the bug.
+              - It represents a complete showstopper for a significant portion of users or for the development process itself.
+            Impact:
+              - Blocks development or testing for the entire team.
+              - Major security vulnerability that could compromise user data or system integrity.
+              - Causes data loss or corruption with no workaround.
+              - Crashes the application or makes a core feature completely unusable for all or most users in a production environment. Will it cause severe quality degration?
+              - Is it preventing contributors from contributing to the repository or is it a release blocker?
+              Qualifier: Is the main function of the software broken?
+              Example: The gemini auth login command fails with an unrecoverable error, preventing any user from authenticating and using the rest of the CLI.
+            P1: High
+              - A P1 bug is a serious issue that significantly degrades the user experience or impacts a core feature.
+              - While not a complete blocker, it's a major problem that needs a fast resolution. Feature requests are almost never P1.
+              - Once again this would be affecting many users.
+              - You would see this in the form of comments from different developers on the bug.
+              Impact:
+              - A core feature is broken or behaving incorrectly for a large number of users or large number of use cases.
+              - Review the bug details and comments to try figure out if this issue affects a large set of use cases or if it's a narrow set of use cases.
+              - Severe performance degradation making the application frustratingly slow.
+              - No straightforward workaround exists, or the workaround is difficult and non-obvious.
+              Qualifier: Is a key feature unusable or giving very wrong results?
+              Example: Gemini CLI enters a loop when making read-many-files tool call. I am unable to break out of the loop and gemini doesn't follow instructions subsequently.
+            P2: Medium
+              - A P2 bug is a moderately impactful issue. It's a noticeable problem but doesn't prevent the use of the software's main functionality.
+              Impact:
+              - Affects a non-critical feature or a smaller, specific subset of users.
+              - An inconvenient but functional workaround is available and easy to execute.
+              - Noticeable UI/UX problems that don't break functionality but look unprofessional (e.g., elements are misaligned or overlapping).
+              Qualifier: Is it an annoying but non-blocking problem?
+              Example: An error message is unclear or contains a typo, causing user confusion but not halting their workflow.
+            P3: Low
+              - A P3 bug is a minor, low-impact issue that is trivial or cosmetic. It has little to no effect on the overall functionality of the application.
+              Impact:
+              - Minor cosmetic issues like color inconsistencies, typos in documentation, or slight alignment problems on a non-critical page.
+              - An edge-case bug that is very difficult to reproduce and affects a tiny fraction of users.
+              Qualifier: Is it a "nice-to-fix" issue?
+              Example: Spelling mistakes etc.
+            Additional Context:
+              - If users are talking about issues where the model gets downgraded from pro to flash then i want you to categorize that as a performance issue
+              - This product is designed to use different models eg.. using pro, downgrading to flash etc.
+              - When users report that they dont expect the model to change those would be categorized as feature requests.
+            Definition of Categories and Scopes
+
+            category/cli: Command line interface and interaction
+            - Issues with interactive CLI features, command parsing, keyboard shortcuts
+            - Related scopes: scope/commands, scope/interactive, scope/non-interactive, scope/keybindings
+
+            category/core: Core engine and logic
+            - Issues with fundamental components, content generation, session management
+            - Related scopes: scope/content-generation, scope/token-management, scope/session-management, scope/model-switching
+
+            category/ui: User interface and display
+            - Issues with themes, UI components, rendering, markdown display
+            - Related scopes: scope/themes, scope/components, scope/rendering, scope/markdown
+
+            category/authentication: Authentication and authorization
+            - Issues with login flows, API keys, OAuth, credential storage
+            - Related scopes: scope/oauth, scope/api-keys, scope/token-storage
+
+            category/tools: Tool integration and execution
+            - Issues with MCP, shell execution, file operations, web search, memory, git integration
+            - Related scopes: scope/mcp, scope/shell, scope/file-operations, scope/web-search, scope/memory, scope/git
+
+            category/configuration: Configuration management
+            - Issues with settings, extensions, trusted folders, sandbox configuration
+            - Related scopes: scope/settings, scope/extensions, scope/trusted-folders, scope/sandbox
+
+            category/integration: External integrations
+            - Issues with IDE integration, VSCode extension, Zed integration, GitHub Actions
+            - Related scopes: scope/ide, scope/vscode, scope/zed, scope/github-actions
+
+            category/platform: Platform compatibility
+            - Issues with installation, OS compatibility, packaging
+            - Related scopes: scope/installation, scope/macos, scope/windows, scope/linux, scope/packaging
+
+            category/performance: Performance and optimization
+            - Issues with latency, memory usage, model performance, caching
+            - Related scopes: scope/latency, scope/memory-usage, scope/model-performance, scope/caching
+
+            category/security: Security and privacy
+            - Issues with data privacy, credential security, vulnerabilities
+            - Related scopes: scope/data-privacy, scope/credential-security, scope/vulnerability
+
+            category/telemetry: Telemetry and analytics
+            - Issues with metrics collection, logging, analytics
+            - Related scopes: scope/metrics, scope/logging, scope/analytics
+
+            category/development: Development experience
+            - Issues with build system, testing, CI/CD, documentation
+            - Related scopes: scope/build-system, scope/testing, scope/ci-cd, scope/documentation

.github/workflows/release-sdk.yml

@@ -0,0 +1,237 @@
+name: 'Release SDK'
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'The version to release (e.g., v0.1.11). Required for manual patch releases.'
+        required: false
+        type: 'string'
+      ref:
+        description: 'The branch or ref (full git sha) to release from.'
+        required: true
+        type: 'string'
+        default: 'main'
+      dry_run:
+        description: 'Run a dry-run of the release process; no branches, npm packages or GitHub releases will be created.'
+        required: true
+        type: 'boolean'
+        default: true
+      create_nightly_release:
+        description: 'Auto apply the nightly release tag, input version is ignored.'
+        required: false
+        type: 'boolean'
+        default: false
+      create_preview_release:
+        description: 'Auto apply the preview release tag, input version is ignored.'
+        required: false
+        type: 'boolean'
+        default: false
+      force_skip_tests:
+        description: 'Select to skip the "Run Tests" step in testing. Prod releases should run tests'
+        required: false
+        type: 'boolean'
+        default: false
+
+jobs:
+  release-sdk:
+    runs-on: 'ubuntu-latest'
+    environment:
+      name: 'production-release'
+      url: '${{ github.server_url }}/${{ github.repository }}/releases/tag/sdk-typescript-${{ steps.version.outputs.RELEASE_TAG }}'
+    if: |-
+      ${{ github.repository == 'QwenLM/qwen-code' }}
+    permissions:
+      contents: 'write'
+      packages: 'write'
+      id-token: 'write'
+      issues: 'write'
+    outputs:
+      RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
+
+    steps:
+      - name: 'Checkout'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
+        with:
+          ref: '${{ github.event.inputs.ref || github.sha }}'
+          fetch-depth: 0
+
+      - name: 'Set booleans for simplified logic'
+        env:
+          CREATE_NIGHTLY_RELEASE: '${{ github.event.inputs.create_nightly_release }}'
+          CREATE_PREVIEW_RELEASE: '${{ github.event.inputs.create_preview_release }}'
+          DRY_RUN_INPUT: '${{ github.event.inputs.dry_run }}'
+        id: 'vars'
+        run: |-
+          is_nightly="false"
+          if [[ "${CREATE_NIGHTLY_RELEASE}" == "true" ]]; then
+            is_nightly="true"
+          fi
+          echo "is_nightly=${is_nightly}" >> "${GITHUB_OUTPUT}"
+
+          is_preview="false"
+          if [[ "${CREATE_PREVIEW_RELEASE}" == "true" ]]; then
+            is_preview="true"
+          fi
+          echo "is_preview=${is_preview}" >> "${GITHUB_OUTPUT}"
+
+          is_dry_run="false"
+          if [[ "${DRY_RUN_INPUT}" == "true" ]]; then
+            is_dry_run="true"
+          fi
+          echo "is_dry_run=${is_dry_run}" >> "${GITHUB_OUTPUT}"
+
+      - name: 'Setup Node.js'
+        uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4
+        with:
+          node-version-file: '.nvmrc'
+          cache: 'npm'
+
+      - name: 'Install Dependencies'
+        run: |-
+          npm ci
+
+      - name: 'Get the version'
+        id: 'version'
+        run: |
+          VERSION_ARGS=()
+          if [[ "${IS_NIGHTLY}" == "true" ]]; then
+            VERSION_ARGS+=(--type=nightly)
+          elif [[ "${IS_PREVIEW}" == "true" ]]; then
+            VERSION_ARGS+=(--type=preview)
+            if [[ -n "${MANUAL_VERSION}" ]]; then
+              VERSION_ARGS+=("--preview_version_override=${MANUAL_VERSION}")
+            fi
+          else
+            VERSION_ARGS+=(--type=stable)
+            if [[ -n "${MANUAL_VERSION}" ]]; then
+              VERSION_ARGS+=("--stable_version_override=${MANUAL_VERSION}")
+            fi
+          fi
+
+          VERSION_JSON=$(node packages/sdk-typescript/scripts/get-release-version.js "${VERSION_ARGS[@]}")
+          echo "RELEASE_TAG=$(echo "$VERSION_JSON" | jq -r .releaseTag)" >> "$GITHUB_OUTPUT"
+          echo "RELEASE_VERSION=$(echo "$VERSION_JSON" | jq -r .releaseVersion)" >> "$GITHUB_OUTPUT"
+          echo "NPM_TAG=$(echo "$VERSION_JSON" | jq -r .npmTag)" >> "$GITHUB_OUTPUT"
+
+          echo "PREVIOUS_RELEASE_TAG=$(echo "$VERSION_JSON" | jq -r .previousReleaseTag)" >> "$GITHUB_OUTPUT"
+        env:
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          IS_NIGHTLY: '${{ steps.vars.outputs.is_nightly }}'
+          IS_PREVIEW: '${{ steps.vars.outputs.is_preview }}'
+          MANUAL_VERSION: '${{ inputs.version }}'
+
+      - name: 'Run Tests'
+        if: |-
+          ${{ github.event.inputs.force_skip_tests != 'true' }}
+        working-directory: 'packages/sdk-typescript'
+        run: |
+          npm run test:ci
+        env:
+          OPENAI_API_KEY: '${{ secrets.OPENAI_API_KEY }}'
+          OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'
+          OPENAI_MODEL: '${{ secrets.OPENAI_MODEL }}'
+
+      - name: 'Build CLI for Integration Tests'
+        if: |-
+          ${{ github.event.inputs.force_skip_tests != 'true' }}
+        run: |
+          npm run build
+          npm run bundle
+
+      - name: 'Run SDK Integration Tests'
+        if: |-
+          ${{ github.event.inputs.force_skip_tests != 'true' }}
+        run: |
+          npm run test:integration:sdk:sandbox:none
+          npm run test:integration:sdk:sandbox:docker
+        env:
+          OPENAI_API_KEY: '${{ secrets.OPENAI_API_KEY }}'
+          OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'
+          OPENAI_MODEL: '${{ secrets.OPENAI_MODEL }}'
+
+      - name: 'Configure Git User'
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: 'Create and switch to a release branch'
+        id: 'release_branch'
+        env:
+          RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
+        run: |-
+          BRANCH_NAME="release/sdk-typescript/${RELEASE_TAG}"
+          git switch -c "${BRANCH_NAME}"
+          echo "BRANCH_NAME=${BRANCH_NAME}" >> "${GITHUB_OUTPUT}"
+
+      - name: 'Update package version'
+        working-directory: 'packages/sdk-typescript'
+        env:
+          RELEASE_VERSION: '${{ steps.version.outputs.RELEASE_VERSION }}'
+        run: |-
+          npm version "${RELEASE_VERSION}" --no-git-tag-version --allow-same-version
+
+      - name: 'Commit and Conditionally Push package version'
+        env:
+          BRANCH_NAME: '${{ steps.release_branch.outputs.BRANCH_NAME }}'
+          IS_DRY_RUN: '${{ steps.vars.outputs.is_dry_run }}'
+          RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
+        run: |-
+          git add packages/sdk-typescript/package.json
+          if git diff --staged --quiet; then
+            echo "No version changes to commit"
+          else
+            git commit -m "chore(release): sdk-typescript ${RELEASE_TAG}"
+          fi
+          if [[ "${IS_DRY_RUN}" == "false" ]]; then
+            echo "Pushing release branch to remote..."
+            git push --set-upstream origin "${BRANCH_NAME}" --follow-tags
+          else
+            echo "Dry run enabled. Skipping push."
+          fi
+
+      - name: 'Build SDK'
+        working-directory: 'packages/sdk-typescript'
+        run: |-
+          npm run build
+
+      - name: 'Configure npm for publishing'
+        uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4
+        with:
+          node-version-file: '.nvmrc'
+          registry-url: 'https://registry.npmjs.org'
+          scope: '@qwen-code'
+
+      - name: 'Publish @qwen-code/sdk'
+        working-directory: 'packages/sdk-typescript'
+        run: |-
+          npm publish --access public --tag=${{ steps.version.outputs.NPM_TAG }} ${{ steps.vars.outputs.is_dry_run == 'true' && '--dry-run' || '' }}
+        env:
+          NODE_AUTH_TOKEN: '${{ secrets.NPM_TOKEN }}'
+
+      - name: 'Create GitHub Release and Tag'
+        if: |-
+          ${{ steps.vars.outputs.is_dry_run == 'false' }}
+        env:
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          RELEASE_BRANCH: '${{ steps.release_branch.outputs.BRANCH_NAME }}'
+          RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
+          PREVIOUS_RELEASE_TAG: '${{ steps.version.outputs.PREVIOUS_RELEASE_TAG }}'
+        run: |-
+          gh release create "sdk-typescript-${RELEASE_TAG}" \
+            --target "$RELEASE_BRANCH" \
+            --title "SDK TypeScript Release ${RELEASE_TAG}" \
+            --notes-start-tag "sdk-typescript-${PREVIOUS_RELEASE_TAG}" \
+            --generate-notes
+
+      - name: 'Create Issue on Failure'
+        if: |-
+          ${{ failure() }}
+        env:
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          RELEASE_TAG: "${{ steps.version.outputs.RELEASE_TAG || 'N/A' }}"
+          DETAILS_URL: '${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}'
+        run: |-
+          gh issue create \
+            --title "SDK Release Failed for ${RELEASE_TAG} on $(date +'%Y-%m-%d')" \
+            --body "The SDK release workflow failed. See the full run for details: ${DETAILS_URL}"

.github/workflows/release.yml

@@ -1,175 +1,227 @@
-name: Release
+name: 'Release'
 
 on:
   schedule:
     # Runs every day at midnight UTC for the nightly release.
     - cron: '0 0 * * *'
+    # Runs every Tuesday at 23:59 UTC for the preview release.
+    - cron: '59 23 * * 2'
   workflow_dispatch:
     inputs:
       version:
         description: 'The version to release (e.g., v0.1.11). Required for manual patch releases.'
         required: false # Not required for scheduled runs
-        type: string
+        type: 'string'
       ref:
         description: 'The branch or ref (full git sha) to release from.'
         required: true
-        type: string
+        type: 'string'
         default: 'main'
       dry_run:
         description: 'Run a dry-run of the release process; no branches, npm packages or GitHub releases will be created.'
         required: true
-        type: boolean
+        type: 'boolean'
         default: true
       create_nightly_release:
         description: 'Auto apply the nightly release tag, input version is ignored.'
         required: false
-        type: boolean
+        type: 'boolean'
+        default: false
+      create_preview_release:
+        description: 'Auto apply the preview release tag, input version is ignored.'
+        required: false
+        type: 'boolean'
         default: false
       force_skip_tests:
         description: 'Select to skip the "Run Tests" step in testing. Prod releases should run tests'
         required: false
-        type: boolean
+        type: 'boolean'
         default: false
 
 jobs:
   release:
-    runs-on: ubuntu-latest
+    runs-on: 'ubuntu-latest'
     environment:
-      name: production-release
-      url: ${{ github.server_url }}/${{ github.repository }}/releases/tag/${{ steps.version.outputs.RELEASE_TAG }}
-    if: github.repository == 'QwenLM/qwen-code'
+      name: 'production-release'
+      url: '${{ github.server_url }}/${{ github.repository }}/releases/tag/${{ steps.version.outputs.RELEASE_TAG }}'
+    if: |-
+      ${{ github.repository == 'QwenLM/qwen-code' }}
     permissions:
-      contents: write
-      packages: write
-      id-token: write
-      issues: write # For creating issues on failure
+      contents: 'write'
+      packages: 'write'
+      id-token: 'write'
+      issues: 'write' # For creating issues on failure
     outputs:
-      RELEASE_TAG: ${{ steps.version.outputs.RELEASE_TAG }}
+      RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
 
     steps:
-      - name: Checkout code
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+      - name: 'Checkout'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
         with:
-          ref: ${{ github.sha }}
+          ref: '${{ github.event.inputs.ref || github.sha }}'
           fetch-depth: 0
 
-      - name: Set booleans for simplified logic
-        id: vars
-        run: |
+      - name: 'Set booleans for simplified logic'
+        env:
+          CREATE_NIGHTLY_RELEASE: '${{ github.event.inputs.create_nightly_release }}'
+          CREATE_PREVIEW_RELEASE: '${{ github.event.inputs.create_preview_release }}'
+          EVENT_NAME: '${{ github.event_name }}'
+          CRON: '${{ github.event.schedule }}'
+          DRY_RUN_INPUT: '${{ github.event.inputs.dry_run }}'
+        id: 'vars'
+        run: |-
           is_nightly="false"
-          if [[ "${{ github.event_name }}" == "schedule" || "${{ github.event.inputs.create_nightly_release }}" == "true" ]]; then
+          if [[ "${CRON}" == "0 0 * * *" || "${CREATE_NIGHTLY_RELEASE}" == "true" ]]; then
             is_nightly="true"
           fi
-          echo "is_nightly=${is_nightly}" >> $GITHUB_OUTPUT
+          echo "is_nightly=${is_nightly}" >> "${GITHUB_OUTPUT}"
+
+          is_preview="false"
+          if [[ "${CRON}" == "59 23 * * 2" || "${CREATE_PREVIEW_RELEASE}" == "true" ]]; then
+            is_preview="true"
+          fi
+          echo "is_preview=${is_preview}" >> "${GITHUB_OUTPUT}"
 
           is_dry_run="false"
-          if [[ "${{ github.event.inputs.dry_run }}" == "true" ]]; then
+          if [[ "${DRY_RUN_INPUT}" == "true" ]]; then
             is_dry_run="true"
           fi
-          echo "is_dry_run=${is_dry_run}" >> $GITHUB_OUTPUT
+          echo "is_dry_run=${is_dry_run}" >> "${GITHUB_OUTPUT}"
 
-      - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      - name: 'Setup Node.js'
+        uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4
         with:
-          node-version: '20'
+          node-version-file: '.nvmrc'
           cache: 'npm'
 
-      - name: Install Dependencies
-        run: npm ci
+      - name: 'Install Dependencies'
+        run: |-
+          npm ci
 
-      - name: Get the version
-        id: version
+      - name: 'Get the version'
+        id: 'version'
         run: |
-          VERSION_JSON=$(node scripts/get-release-version.js)
-          echo "RELEASE_TAG=$(echo $VERSION_JSON | jq -r .releaseTag)" >> $GITHUB_OUTPUT
-          echo "RELEASE_VERSION=$(echo $VERSION_JSON | jq -r .releaseVersion)" >> $GITHUB_OUTPUT
-          echo "NPM_TAG=$(echo $VERSION_JSON | jq -r .npmTag)" >> $GITHUB_OUTPUT
-        env:
-          IS_NIGHTLY: ${{ steps.vars.outputs.is_nightly }}
-          MANUAL_VERSION: ${{ inputs.version }}
+          VERSION_ARGS=()
+          if [[ "${IS_NIGHTLY}" == "true" ]]; then
+            VERSION_ARGS+=(--type=nightly)
+          elif [[ "${IS_PREVIEW}" == "true" ]]; then
+            VERSION_ARGS+=(--type=preview)
+            if [[ -n "${MANUAL_VERSION}" ]]; then
+              VERSION_ARGS+=("--preview_version_override=${MANUAL_VERSION}")
+            fi
+          else
+            VERSION_ARGS+=(--type=stable)
+            if [[ -n "${MANUAL_VERSION}" ]]; then
+              VERSION_ARGS+=("--stable_version_override=${MANUAL_VERSION}")
+            fi
+          fi
 
-      - name: Run Tests
-        if: github.event.inputs.force_skip_tests != 'true'
+          VERSION_JSON=$(node scripts/get-release-version.js "${VERSION_ARGS[@]}")
+          echo "RELEASE_TAG=$(echo "$VERSION_JSON" | jq -r .releaseTag)" >> "$GITHUB_OUTPUT"
+          echo "RELEASE_VERSION=$(echo "$VERSION_JSON" | jq -r .releaseVersion)" >> "$GITHUB_OUTPUT"
+          echo "NPM_TAG=$(echo "$VERSION_JSON" | jq -r .npmTag)" >> "$GITHUB_OUTPUT"
+
+          echo "PREVIOUS_RELEASE_TAG=$(echo "$VERSION_JSON" | jq -r .previousReleaseTag)" >> "$GITHUB_OUTPUT"
+        env:
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          IS_NIGHTLY: '${{ steps.vars.outputs.is_nightly }}'
+          IS_PREVIEW: '${{ steps.vars.outputs.is_preview }}'
+          MANUAL_VERSION: '${{ inputs.version }}'
+
+      - name: 'Run Tests'
+        if: |-
+          ${{ github.event.inputs.force_skip_tests != 'true' }}
         run: |
           npm run preflight
           npm run test:integration:sandbox:none
           npm run test:integration:sandbox:docker
         env:
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          OPENAI_BASE_URL: ${{ secrets.OPENAI_BASE_URL }}
-          OPENAI_MODEL: ${{ secrets.OPENAI_MODEL }}
+          OPENAI_API_KEY: '${{ secrets.OPENAI_API_KEY }}'
+          OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'
+          OPENAI_MODEL: '${{ secrets.OPENAI_MODEL }}'
 
-      - name: Configure Git User
+      - name: 'Configure Git User'
         run: |
           git config user.name "github-actions[bot]"
           git config user.email "github-actions[bot]@users.noreply.github.com"
 
-      - name: Create and switch to a release branch
-        id: release_branch
-        run: |
-          BRANCH_NAME="release/${{ steps.version.outputs.RELEASE_TAG }}"
-          git switch -c $BRANCH_NAME
-          echo "BRANCH_NAME=${BRANCH_NAME}" >> $GITHUB_OUTPUT
+      - name: 'Create and switch to a release branch'
+        id: 'release_branch'
+        env:
+          RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
+        run: |-
+          BRANCH_NAME="release/${RELEASE_TAG}"
+          git switch -c "${BRANCH_NAME}"
+          echo "BRANCH_NAME=${BRANCH_NAME}" >> "${GITHUB_OUTPUT}"
 
-      - name: Update package versions
-        run: |
-          npm run release:version ${{ steps.version.outputs.RELEASE_VERSION }}
+      - name: 'Update package versions'
+        env:
+          RELEASE_VERSION: '${{ steps.version.outputs.RELEASE_VERSION }}'
+        run: |-
+          npm run release:version "${RELEASE_VERSION}"
 
-      - name: Commit and Conditionally Push package versions
-        run: |
+      - name: 'Commit and Conditionally Push package versions'
+        env:
+          BRANCH_NAME: '${{ steps.release_branch.outputs.BRANCH_NAME }}'
+          IS_DRY_RUN: '${{ steps.vars.outputs.is_dry_run }}'
+          RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
+        run: |-
           git add package.json package-lock.json packages/*/package.json
-          git commit -m "chore(release): ${{ steps.version.outputs.RELEASE_TAG }}"
-          if [[ "${{ steps.vars.outputs.is_dry_run }}" == "false" ]]; then
+          if git diff --staged --quiet; then
+            echo "No version changes to commit"
+          else
+            git commit -m "chore(release): ${RELEASE_TAG}"
+          fi
+          if [[ "${IS_DRY_RUN}" == "false" ]]; then
             echo "Pushing release branch to remote..."
-            git push --set-upstream origin ${{ steps.release_branch.outputs.BRANCH_NAME }} --follow-tags
+            git push --set-upstream origin "${BRANCH_NAME}" --follow-tags
           else
             echo "Dry run enabled. Skipping push."
           fi
 
-      - name: Build and Prepare Packages
-        run: |
-          npm run build:packages
+      - name: 'Build Bundle and Prepare Package'
+        run: |-
+          npm run bundle
           npm run prepare:package
 
-      - name: Configure npm for publishing
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      - name: 'Configure npm for publishing'
+        uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4
         with:
           node-version: '20'
           registry-url: 'https://registry.npmjs.org'
           scope: '@qwen-code'
 
-      - name: Publish @qwen-code/qwen-code-core
-        run: npm publish --workspace=@qwen-code/qwen-code-core --access public --tag=${{ steps.version.outputs.NPM_TAG }} ${{ steps.vars.outputs.is_dry_run == 'true' && '--dry-run' || '' }}
+      - name: 'Publish @qwen-code/qwen-code'
+        working-directory: 'dist'
+        run: |-
+          npm publish --access public --tag=${{ steps.version.outputs.NPM_TAG }} ${{ steps.vars.outputs.is_dry_run == 'true' && '--dry-run' || '' }}
         env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NODE_AUTH_TOKEN: '${{ secrets.NPM_TOKEN }}'
 
-      - name: Install latest core package
-        if: steps.vars.outputs.is_dry_run == 'false'
-        run: npm install @qwen-code/qwen-code-core@${{ steps.version.outputs.RELEASE_VERSION }} --workspace=@qwen-code/qwen-code --save-exact
-
-      - name: Publish @qwen-code/qwen-code
-        run: npm publish --workspace=@qwen-code/qwen-code --access public --tag=${{ steps.version.outputs.NPM_TAG }} ${{ steps.vars.outputs.is_dry_run == 'true' && '--dry-run' || '' }}
+      - name: 'Create GitHub Release and Tag'
+        if: |-
+          ${{ steps.vars.outputs.is_dry_run == 'false' }}
         env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-      - name: Create GitHub Release and Tag
-        if: ${{ steps.vars.outputs.is_dry_run == 'false' }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          RELEASE_BRANCH: ${{ steps.release_branch.outputs.BRANCH_NAME }}
-        run: |
-          gh release create ${{ steps.version.outputs.RELEASE_TAG }} \
-            bundle/gemini.js \
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          RELEASE_BRANCH: '${{ steps.release_branch.outputs.BRANCH_NAME }}'
+          RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }}'
+          PREVIOUS_RELEASE_TAG: '${{ steps.version.outputs.PREVIOUS_RELEASE_TAG }}'
+        run: |-
+          gh release create "${RELEASE_TAG}" \
+            dist/cli.js \
             --target "$RELEASE_BRANCH" \
-            --title "Release ${{ steps.version.outputs.RELEASE_TAG }}" \
+            --title "Release ${RELEASE_TAG}" \
+            --notes-start-tag "$PREVIOUS_RELEASE_TAG" \
             --generate-notes
 
-      - name: Create Issue on Failure
-        if: failure()
-        run: |
-          gh issue create \
-            --title "Release Failed for ${{ steps.version.outputs.RELEASE_TAG || 'N/A' }} on $(date +'%Y-%m-%d')" \
-            --body "The release workflow failed. See the full run for details: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}" \
-            --label "kind/bug,release-failure"
+      - name: 'Create Issue on Failure'
+        if: |-
+          ${{ failure() }}
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}'
+          RELEASE_TAG: '${{ steps.version.outputs.RELEASE_TAG }} || "N/A"'
+          DETAILS_URL: '${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}'
+        run: |-
+          gh issue create \
+            --title "Release Failed for ${RELEASE_TAG} on $(date +'%Y-%m-%d')" \
+            --body "The release workflow failed. See the full run for details: ${DETAILS_URL}"

.github/workflows/stale.yml

@@ -1,38 +1,39 @@
-name: Mark stale issues and pull requests
+name: 'Mark stale issues and pull requests'
 
 # Run as a daily cron at 1:30 AM
 on:
   schedule:
     - cron: '30 1 * * *'
-  workflow_dispatch: {}
+  workflow_dispatch:
 
 jobs:
   stale:
-    runs-on: ubuntu-latest
-    if: ${{ github.repository == 'google-gemini/gemini-cli' }}
+    runs-on: 'ubuntu-latest'
+    if: |-
+      ${{ github.repository == 'google-gemini/gemini-cli' }}
     permissions:
-      issues: write
-      pull-requests: write
+      issues: 'write'
+      pull-requests: 'write'
     concurrency:
-      group: ${{ github.workflow }}-stale
+      group: '${{ github.workflow }}-stale'
       cancel-in-progress: true
     steps:
-      - uses: actions/stale@5bef64f19d7facfb25b37b414482c7164d639639
+      - uses: 'actions/stale@5bef64f19d7facfb25b37b414482c7164d639639' # ratchet:actions/stale@v9
         with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          stale-issue-message: >
+          repo-token: '${{ secrets.GITHUB_TOKEN }}'
+          stale-issue-message: >-
             This issue has been automatically marked as stale due to 60 days of inactivity.
             It will be closed in 14 days if no further activity occurs.
-          stale-pr-message: >
+          stale-pr-message: >-
             This pull request has been automatically marked as stale due to 60 days of inactivity.
             It will be closed in 14 days if no further activity occurs.
-          close-issue-message: >
+          close-issue-message: >-
             This issue has been closed due to 14 additional days of inactivity after being marked as stale.
             If you believe this is still relevant, feel free to comment or reopen the issue. Thank you!
-          close-pr-message: >
+          close-pr-message: >-
             This pull request has been closed due to 14 additional days of inactivity after being marked as stale.
             If this is still relevant, you are welcome to reopen or leave a comment. Thanks for contributing!
           days-before-stale: 60
           days-before-close: 14
-          exempt-issue-labels: pinned,security
-          exempt-pr-labels: pinned,security
+          exempt-issue-labels: 'pinned,security'
+          exempt-pr-labels: 'pinned,security'

.github/workflows/terminal-bench.yml

@@ -0,0 +1,96 @@
+name: 'Terminal Bench Tests'
+
+on:
+  push:
+    branches:
+      - 'feat/tbench*'
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'The version to test.'
+        required: true
+        type: 'string'
+        default: 'latest'
+  release:
+    types: ['published']
+
+jobs:
+  terminal-bench:
+    name: 'Terminal Bench (Task: ${{ matrix.task_id }})'
+    runs-on: 'ubuntu-latest'
+    strategy:
+      fail-fast: false
+      matrix:
+        task_id:
+          - 'hello-world'
+          - 'swe-bench-astropy-1'
+    steps:
+      - name: 'Checkout'
+        uses: 'actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8' # ratchet:actions/checkout@v5
+        with:
+          submodules: 'recursive'
+      - name: 'Install uv and set the python version'
+        uses: 'astral-sh/setup-uv@557e51de59eb14aaaba2ed9621916900a91d50c6' # v6
+        with:
+          python-version: '3.12'
+
+      - name: 'Set up Node.js 20.x'
+        uses: 'actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020' # ratchet:actions/setup-node@v4
+        with:
+          node-version: '20.x'
+          cache: 'npm'
+          cache-dependency-path: 'package-lock.json'
+          registry-url: 'https://registry.npmjs.org/'
+
+      - name: 'Configure npm for rate limiting'
+        run: |-
+          npm config set fetch-retry-mintimeout 20000
+          npm config set fetch-retry-maxtimeout 120000
+          npm config set fetch-retries 5
+          npm config set fetch-timeout 300000
+
+      - name: 'Install dependencies'
+        run: |-
+          npm ci --prefer-offline --no-audit --progress=false
+
+      - name: 'Build project'
+        run: |-
+          npm run build
+
+      - name: 'Run Terminal Bench Oracle (task: ${{ matrix.task_id }})'
+        run: 'npm run test:terminal-bench:oracle'
+        timeout-minutes: 30
+        env:
+          CI: 'true'
+          NODE_ENV: 'test'
+          VERBOSE: 'true'
+          KEEP_OUTPUT: 'true'
+          TB_TASK_ID: '${{ matrix.task_id }}'
+          TB_TIMEOUT_MINUTES: '30'
+
+      - name: 'Run Terminal Bench Qwen (task: ${{ matrix.task_id }})'
+        run: 'npm run test:terminal-bench:qwen'
+        timeout-minutes: 30
+        env:
+          OPENAI_API_KEY: '${{ secrets.OPENAI_API_KEY }}'
+          OPENAI_BASE_URL: '${{ secrets.OPENAI_BASE_URL }}'
+          OPENAI_MODEL: '${{ secrets.OPENAI_MODEL }}'
+          CI: 'true'
+          NODE_ENV: 'test'
+          VERBOSE: 'true'
+          KEEP_OUTPUT: 'true'
+          TB_TASK_ID: '${{ matrix.task_id }}'
+          TB_TIMEOUT_MINUTES: '30'
+
+      - name: 'Upload test artifacts'
+        if: 'always()'
+        uses: 'actions/upload-artifact@6f51ac03b9356f520e9adb1b1b7802705f340c2b' # ratchet:actions/upload-artifact@v4
+        with:
+          name: 'terminal-bench-${{ matrix.task_id }}-output'
+          path: |
+            .integration-tests/**
+            !.integration-tests/**/*.lock
+            !.integration-tests/**/tb.lock
+            integration-tests/**/*.log
+          if-no-files-found: 'warn'
+          retention-days: 7

.gitignore

@@ -3,18 +3,26 @@
 .env~
 
 # gemini-cli settings
-.gemini/
-!gemini/config.yaml
+# We want to keep the .gemini in the root of the repo and ignore any .gemini
+# in subdirectories. In our root .gemini we want to allow for version control
+# for subcommands.
+**/.gemini/
+!/.gemini/
+.gemini/*
+!.gemini/config.yaml
+!.gemini/commands/
 
 # Note: .gemini-clipboard/ is NOT in gitignore so Gemini can access pasted images
 
 # Dependency directory
 node_modules
 bower_components
+package-lock.json
 
 # Editors
 .idea
 *.iml
+.cursor
 
 # OS metadata
 .DS_Store
@@ -37,9 +45,20 @@ packages/*/coverage/
 
 # Generated files
 packages/cli/src/generated/
+packages/core/src/generated/
 .integration-tests/
 packages/vscode-ide-companion/*.vsix
 
 # Qwen Code Configs
 .qwen/
-logs/
+logs/
+# GHA credentials
+gha-creds-*.json
+
+# Log files
+patch_output.log
+
+# docs build
+docs-site/.next
+# content is a symlink to ../docs
+docs-site/content

.husky/pre-commit

@@ -0,0 +1,9 @@
+npm run pre-commit || {
+  echo ''
+  echo '===================================================='
+  echo 'pre-commit checks failed. in case of emergency, run:'
+  echo ''
+  echo 'git commit --no-verify'
+  echo '===================================================='
+  exit 1
+}

.npmrc

@@ -1,2 +1 @@
 registry=https://registry.npmjs.org
-@google:registry=https://wombat-dressing-room.appspot.com

.prettierignore

@@ -0,0 +1,20 @@
+**/bundle
+**/coverage
+**/dist
+**/.git
+**/node_modules
+.docker
+.DS_Store
+.env
+.gemini/
+.idea
+.integration-tests/
+*.iml
+*.tsbuildinfo
+*.vsix
+bower_components
+eslint.config.js
+**/generated
+gha-creds-*.json
+junit.xml
+Thumbs.db

.vscode/extensions.json

@@ -0,0 +1,7 @@
+{
+  "recommendations": [
+    "vitest.explorer",
+    "esbenp.prettier-vscode",
+    "dbaeumer.vscode-eslint"
+  ]
+}

.vscode/launch.json

@@ -7,22 +7,9 @@
     {
       "type": "node",
       "request": "launch",
-      "name": "Launch CLI",
+      "name": "Build & Launch CLI",
       "runtimeExecutable": "npm",
-      "runtimeArgs": ["run", "start"],
-      "skipFiles": ["<node_internals>/**"],
-      "cwd": "${workspaceFolder}",
-      "console": "integratedTerminal",
-      "env": {
-        "GEMINI_SANDBOX": "false"
-      }
-    },
-    {
-      "type": "node",
-      "request": "launch",
-      "name": "Launch E2E",
-      "program": "${workspaceFolder}/integration-tests/run-tests.js",
-      "args": ["--verbose", "--keep-output", "list_directory"],
+      "runtimeArgs": ["run", "build-and-start"],
       "skipFiles": ["<node_internals>/**"],
       "cwd": "${workspaceFolder}",
       "console": "integratedTerminal",
@@ -40,7 +27,7 @@
       "outFiles": [
         "${workspaceFolder}/packages/vscode-ide-companion/dist/**/*.js"
       ],
-      "preLaunchTask": "npm: build: vscode-ide-companion"
+      "preLaunchTask": "launch: vscode-ide-companion (copy+build)"
     },
     {
       "name": "Attach",
@@ -80,6 +67,66 @@
       "console": "integratedTerminal",
       "internalConsoleOptions": "neverOpen",
       "skipFiles": ["<node_internals>/**"]
+    },
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Launch CLI Non-Interactive",
+      "runtimeExecutable": "npm",
+      "runtimeArgs": [
+        "run",
+        "start",
+        "--",
+        "-p",
+        "${input:prompt}",
+        "--output-format",
+        "stream-json"
+      ],
+      "skipFiles": ["<node_internals>/**"],
+      "cwd": "${workspaceFolder}",
+      "console": "integratedTerminal",
+      "env": {
+        "GEMINI_SANDBOX": "false"
+      }
+    },
+    {
+      "name": "Debug Integration Test File",
+      "type": "node",
+      "request": "launch",
+      "runtimeExecutable": "npx",
+      "runtimeArgs": [
+        "vitest",
+        "run",
+        "--root",
+        "./integration-tests",
+        "--inspect-brk=9229",
+        "${file}"
+      ],
+      "cwd": "${workspaceFolder}",
+      "console": "integratedTerminal",
+      "internalConsoleOptions": "neverOpen",
+      "skipFiles": ["<node_internals>/**"],
+      "env": {
+        "GEMINI_SANDBOX": "false"
+      }
+    },
+    {
+      "name": "Attach by Process ID",
+      "processId": "${command:PickProcess}",
+      "request": "attach",
+      "skipFiles": ["<node_internals>/**"],
+      "type": "node"
+    },
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Debug Current TS File",
+      "runtimeExecutable": "npx",
+      "runtimeArgs": ["tsx", "${file}"],
+      "skipFiles": ["<node_internals>/**"],
+      "cwd": "${workspaceFolder}",
+      "console": "integratedTerminal",
+      "env": {}
     }
   ],
   "inputs": [
@@ -88,6 +135,18 @@
       "type": "promptString",
       "description": "Enter the path to the test file (e.g., ${workspaceFolder}/packages/cli/src/ui/components/LoadingIndicator.test.tsx)",
       "default": "${workspaceFolder}/packages/cli/src/ui/components/LoadingIndicator.test.tsx"
+    },
+    {
+      "id": "prompt",
+      "type": "promptString",
+      "description": "Enter your prompt for non-interactive mode",
+      "default": "Explain this code"
+    },
+    {
+      "id": "debugPort",
+      "type": "promptString",
+      "description": "Enter the debug port number (default: 9229)",
+      "default": "9229"
     }
   ]
 }

.vscode/settings.json

@@ -1,3 +1,17 @@
 {
-  "typescript.tsserver.experimental.enableProjectDiagnostics": true
+  "typescript.tsserver.experimental.enableProjectDiagnostics": true,
+  "editor.tabSize": 2,
+  "editor.rulers": [80],
+  "editor.detectIndentation": false,
+  "editor.insertSpaces": true,
+  "[typescript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[json]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[javascript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "vitest.disableWorkspaceWarning": true
 }

.vscode/tasks.json

@@ -20,6 +20,22 @@
       "problemMatcher": [],
       "label": "npm: build: vscode-ide-companion",
       "detail": "npm run build -w packages/vscode-ide-companion"
+    },
+    {
+      "label": "copy: bundled-cli (dev)",
+      "type": "shell",
+      "command": "node",
+      "args": ["packages/vscode-ide-companion/scripts/copy-bundled-cli.js"],
+      "problemMatcher": []
+    },
+    {
+      "label": "launch: vscode-ide-companion (copy+build)",
+      "dependsOrder": "sequence",
+      "dependsOn": [
+        "copy: bundled-cli (dev)",
+        "npm: build: vscode-ide-companion"
+      ],
+      "problemMatcher": []
     }
   ]
 }

.yamllint.yml

@@ -0,0 +1,90 @@
+rules:
+  anchors:
+    forbid-duplicated-anchors: true
+    forbid-undeclared-aliases: true
+    forbid-unused-anchors: true
+
+  braces:
+    forbid: 'non-empty'
+    min-spaces-inside-empty: 0
+    max-spaces-inside-empty: 0
+
+  brackets:
+    min-spaces-inside: 0
+    max-spaces-inside: 0
+    min-spaces-inside-empty: 0
+    max-spaces-inside-empty: 0
+
+  colons:
+    max-spaces-before: 0
+    max-spaces-after: 1
+
+  commas:
+    max-spaces-before: 0
+    min-spaces-after: 1
+    max-spaces-after: 1
+
+  comments:
+    require-starting-space: true
+    ignore-shebangs: true
+    min-spaces-from-content: 1
+
+  comments-indentation: 'disable'
+
+  document-end:
+    present: false
+
+  document-start:
+    present: false
+
+  empty-lines:
+    max: 2
+    max-start: 0
+    max-end: 1
+
+  empty-values:
+    forbid-in-block-mappings: false
+    forbid-in-flow-mappings: true
+
+  float-values:
+    forbid-inf: false
+    forbid-nan: false
+    forbid-scientific-notation: false
+    require-numeral-before-decimal: false
+
+  hyphens:
+    max-spaces-after: 1
+
+  indentation:
+    spaces: 2
+    indent-sequences: true
+    check-multi-line-strings: false
+
+  key-duplicates: {}
+
+  new-line-at-end-of-file: {}
+
+  new-lines:
+    type: 'unix'
+
+  octal-values:
+    forbid-implicit-octal: true
+    forbid-explicit-octal: false
+
+  quoted-strings:
+    quote-type: 'single'
+    required: true
+    allow-quoted-quotes: true
+
+  trailing-spaces: {}
+
+  truthy:
+    allowed-values: ['true', 'false', 'on'] # GitHub Actions uses "on"
+    check-keys: true
+
+ignore:
+  - 'thirdparty/'
+  - 'third_party/'
+  - 'vendor/'
+  - 'node_modules/'
+  - 'integration-tests/terminal-bench/'

CHANGELOG.md

@@ -0,0 +1,121 @@
+# Changelog
+
+## 0.0.14
+
+- Added plan mode support for task planning
+- Fixed unreliable editCorrector that injects extra escape characters
+- Fixed task tool dynamic updates
+- Added Qwen3-VL-Plus token limits (256K input, 32K output) and highres support
+- Enhanced dashScope cache control
+
+## 0.0.13
+
+- Added YOLO mode support for automatic vision model switching with CLI arguments and environment variables.
+- Fixed ripgrep lazy loading to resolve VS Code IDE companion startup issues.
+- Fixed authentication hang when selecting Qwen OAuth.
+- Added OpenAI and Qwen OAuth authentication support to Zed ACP integration.
+- Fixed output token limit for Qwen models.
+- Fixed Markdown list display issues on Windows.
+- Enhanced vision model instructions and documentation.
+- Improved authentication method compatibility across different IDE integrations.
+
+## 0.0.12
+
+- Added vision model support for Qwen-OAuth authentication.
+- Synced upstream `gemini-cli` to v0.3.4 with numerous improvements and bug fixes.
+- Enhanced subagent functionality with system reminders and improved user experience.
+- Added tool call type coercion for better compatibility.
+- Fixed arrow key navigation issues on Windows.
+- Fixed missing tool call chunks for OpenAI logging.
+- Fixed system prompt issues to avoid malformed tool calls.
+- Fixed terminal flicker when subagent is executing.
+- Fixed duplicate subagents configuration when running in home directory.
+- Fixed Esc key unable to cancel subagent dialog.
+- Added confirmation prompt for `/init` command when context file exists.
+- Added `skipLoopDetection` configuration option.
+- Fixed `is_background` parameter reset issues.
+- Enhanced Windows compatibility with multi-line paste handling.
+- Improved subagent documentation and branding consistency.
+- Fixed various linting errors and improved code quality.
+- Miscellaneous improvements and bug fixes.
+
+## 0.0.11
+
+- Added subagents feature with file-based configuration system for specialized AI assistants.
+- Added Welcome Back Dialog with project summary and enhanced quit options.
+- Fixed performance issues with SharedTokenManager causing 20-minute delays.
+- Fixed tool calls UI issues and improved user experience.
+- Fixed credential clearing when switching authentication types.
+- Enhanced subagent capabilities to use tools requiring user confirmation.
+- Improved ReadManyFiles tool with shared line limits across files.
+- Re-implemented tokenLimits class for better compatibility with Qwen and other model types.
+- Fixed chunk validation to avoid unnecessary retries.
+- Resolved EditTool naming inconsistency causing agent confusion loops.
+- Fixed unexpected re-authentication when auth-token is expired.
+- Added Terminal Bench integration tests.
+- Updated multilingual documentation links in README.
+- Fixed various Windows compatibility issues.
+- Miscellaneous improvements and bug fixes.
+
+## 0.0.10
+
+- Synced upstream `gemini-cli` to v0.2.1.
+- Add todo write tool for task management and progress tracking.
+
+## 0.0.9
+
+- Synced upstream `gemini-cli` to v0.1.21.
+- Fixed token synchronization among multiple Qwen sessions.
+- Improved tool execution with early stop on invalid tool calls.
+- Added explicit `is_background` parameter for shell tool.
+- Enhanced memory management with sub-commands to switch between project and global memory operations.
+- Renamed `GEMINI_DIR` to `QWEN_DIR` for better branding consistency.
+- Added support for Qwen Markdown selection.
+- Fixed parallel tool usage and improved tool reliability.
+- Upgraded integration tests to use Vitest framework.
+- Enhanced VS Code IDE integration with launch configurations.
+- Added terminal setup command for Shift+Enter and Ctrl+Enter support.
+- Fixed GitHub Workflows configuration issues.
+- Improved settings directory and command descriptions.
+- Fixed locale handling in yargs configuration.
+- Added support for `trustedFolders.json` configuration file.
+- Enhanced cross-platform compatibility for sandbox build scripts.
+- Improved error handling and fixed ambiguous literals.
+- Updated documentation links and added IDE integration documentation.
+- Miscellaneous improvements and bug fixes.
+
+## 0.0.8
+
+- Synced upstream `gemini-cli` to v0.1.19.
+- Updated documentation branding from **Gemini CLI** to **Qwen Code**.
+- Added multilingual docs links in `README.md`.
+- Added deterministic cache control for the DashScope provider.
+- Added option to choose a project-level or global save location.
+- Limited `grep` results to 25 items by default.
+- `grep` now respects `.qwenignore`.
+- Miscellaneous improvements and bug fixes.
+
+## 0.0.7
+
+- Synced upstream `gemini-cli` to v0.1.18.
+- Fixed MCP tools.
+- Fixed Web Fetch tool.
+- Fixed Web Search tool by switching from Google/Gemini to the Tavily API.
+- Made tool calls tolerant of invalid-JSON parameters occasionally returned by the LLM.
+- Prevented concurrent query submissions in rare cases.
+- Corrected Qwen logger exit-handler setup.
+- Separated static QR code and dynamic spinner components.
+
+## 0.0.6
+
+- Added usage statistics logging for Qwen integration.
+- Made `/init` respect the configured context filename and aligned docs with `QWEN.md`.
+- Fixed `EPERM` error when running `qwen --sandbox` on macOS.
+- Fixed terminal flicker while waiting for login.
+- Fixed `glm-4.5` model request error.
+
+## 0.0.5
+
+- Added Qwen OAuth login and up to 2,000 free requests per day.
+- Synced upstream `gemini-cli` to v0.1.17.
+- Added the `systemPromptMappings` configuration option.

CONTRIBUTING.md

@@ -136,7 +136,7 @@ To start the Gemini CLI from the source code (after building), run the following
 npm start
 ```
 
-If you'd like to run the source build outside of the gemini-cli folder you can utilize `npm link path/to/gemini-cli/packages/cli` (see: [docs](https://docs.npmjs.com/cli/v9/commands/npm-link)) or `alias gemini="node path/to/gemini-cli/packages/cli"` to run with `gemini`
+If you'd like to run the source build outside of the gemini-cli folder, you can utilize `npm link path/to/gemini-cli/packages/cli` (see: [docs](https://docs.npmjs.com/cli/v9/commands/npm-link)) or `alias gemini="node path/to/gemini-cli/packages/cli"` to run with `gemini`
 
 ### Running Tests
 
@@ -209,7 +209,7 @@ npm run lint
 ### Coding Conventions
 
 - Please adhere to the coding style, patterns, and conventions used throughout the existing codebase.
-- Consult [GEMINI.md](https://github.com/google-gemini/gemini-cli/blob/main/GEMINI.md) (typically found in the project root) for specific instructions related to AI-assisted development, including conventions for React, comments, and Git usage.
+- Consult [QWEN.md](https://github.com/QwenLM/qwen-code/blob/main/QWEN.md) (typically found in the project root) for specific instructions related to AI-assisted development, including conventions for React, comments, and Git usage.
 - **Imports:** Pay special attention to import paths. The project uses ESLint to enforce restrictions on relative imports between packages.
 
 ### Project Structure

Dockerfile

@@ -1,3 +1,31 @@
+# Build stage
+FROM docker.io/library/node:20-slim AS builder
+
+# Install build dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+  python3 \
+  make \
+  g++ \
+  git \
+  && apt-get clean \
+  && rm -rf /var/lib/apt/lists/*
+
+# Set up npm global package folder
+RUN mkdir -p /usr/local/share/npm-global
+ENV NPM_CONFIG_PREFIX=/usr/local/share/npm-global
+ENV PATH=$PATH:/usr/local/share/npm-global/bin
+
+# Copy source code
+COPY . /home/node/app
+WORKDIR /home/node/app
+
+# Install dependencies and build packages
+RUN npm ci \
+  && npm run build --workspaces \
+  && npm pack -w @qwen-code/qwen-code --pack-destination ./packages/cli/dist \
+  && npm pack -w @qwen-code/qwen-code-core --pack-destination ./packages/core/dist
+
+# Runtime stage
 FROM docker.io/library/node:20-slim
 
 ARG SANDBOX_NAME="qwen-code-sandbox"
@@ -5,11 +33,9 @@ ARG CLI_VERSION_ARG
 ENV SANDBOX="$SANDBOX_NAME"
 ENV CLI_VERSION=$CLI_VERSION_ARG
 
-# install minimal set of packages, then clean up
+# Install runtime dependencies
 RUN apt-get update && apt-get install -y --no-install-recommends \
   python3 \
-  make \
-  g++ \
   man-db \
   curl \
   dnsutils \
@@ -29,22 +55,19 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
   && apt-get clean \
   && rm -rf /var/lib/apt/lists/*
 
-# set up npm global package folder under /usr/local/share
-# give it to non-root user node, already set up in base image
-RUN mkdir -p /usr/local/share/npm-global \
-  && chown -R node:node /usr/local/share/npm-global
+# Set up npm global package folder
+RUN mkdir -p /usr/local/share/npm-global
 ENV NPM_CONFIG_PREFIX=/usr/local/share/npm-global
 ENV PATH=$PATH:/usr/local/share/npm-global/bin
 
-# switch to non-root user node
-USER node
+# Copy built packages from builder stage
+COPY --from=builder /home/node/app/packages/cli/dist/*.tgz /tmp/
+COPY --from=builder /home/node/app/packages/core/dist/*.tgz /tmp/
 
-# install qwen-code and clean up
-COPY packages/cli/dist/qwen-code-*.tgz /usr/local/share/npm-global/qwen-code.tgz
-COPY packages/core/dist/qwen-code-qwen-code-core-*.tgz /usr/local/share/npm-global/qwen-code-core.tgz
-RUN npm install -g /usr/local/share/npm-global/qwen-code.tgz /usr/local/share/npm-global/qwen-code-core.tgz \
+# Install built packages globally
+RUN npm install -g /tmp/*.tgz \
   && npm cache clean --force \
-  && rm -f /usr/local/share/npm-global/qwen-{code,code-core}.tgz
+  && rm -rf /tmp/*.tgz
 
-# default entrypoint when none specified
-CMD ["qwen"]
+# Default entrypoint when none specified
+CMD ["qwen"]

LICENSE

@@ -200,4 +200,4 @@
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
-   limitations under the License.
+   limitations under the License.

Makefile

@@ -53,7 +53,7 @@ debug:
 
 
 run-npx:
-	npx https://github.com/google-gemini/gemini-cli
+	npx https://github.com/QwenLM/qwen-code
 
 create-alias:
 	scripts/create_alias.sh

QWEN.md

@@ -1,185 +0,0 @@
-## Building and running
-
-Before submitting any changes, it is crucial to validate them by running the full preflight check. This command will build the repository, run all tests, check for type errors, and lint the code.
-
-To run the full suite of checks, execute the following command:
-
-```bash
-npm run preflight
-```
-
-This single command ensures that your changes meet all the quality gates of the project. While you can run the individual steps (`build`, `test`, `typecheck`, `lint`) separately, it is highly recommended to use `npm run preflight` to ensure a comprehensive validation.
-
-## Writing Tests
-
-This project uses **Vitest** as its primary testing framework. When writing tests, aim to follow existing patterns. Key conventions include:
-
-### Test Structure and Framework
-
-- **Framework**: All tests are written using Vitest (`describe`, `it`, `expect`, `vi`).
-- **File Location**: Test files (`*.test.ts` for logic, `*.test.tsx` for React components) are co-located with the source files they test.
-- **Configuration**: Test environments are defined in `vitest.config.ts` files.
-- **Setup/Teardown**: Use `beforeEach` and `afterEach`. Commonly, `vi.resetAllMocks()` is called in `beforeEach` and `vi.restoreAllMocks()` in `afterEach`.
-
-### Mocking (`vi` from Vitest)
-
-- **ES Modules**: Mock with `vi.mock('module-name', async (importOriginal) => { ... })`. Use `importOriginal` for selective mocking.
-  - _Example_: `vi.mock('os', async (importOriginal) => { const actual = await importOriginal(); return { ...actual, homedir: vi.fn() }; });`
-- **Mocking Order**: For critical dependencies (e.g., `os`, `fs`) that affect module-level constants, place `vi.mock` at the _very top_ of the test file, before other imports.
-- **Hoisting**: Use `const myMock = vi.hoisted(() => vi.fn());` if a mock function needs to be defined before its use in a `vi.mock` factory.
-- **Mock Functions**: Create with `vi.fn()`. Define behavior with `mockImplementation()`, `mockResolvedValue()`, or `mockRejectedValue()`.
-- **Spying**: Use `vi.spyOn(object, 'methodName')`. Restore spies with `mockRestore()` in `afterEach`.
-
-### Commonly Mocked Modules
-
-- **Node.js built-ins**: `fs`, `fs/promises`, `os` (especially `os.homedir()`), `path`, `child_process` (`execSync`, `spawn`).
-- **External SDKs**: `@google/genai`, `@modelcontextprotocol/sdk`.
-- **Internal Project Modules**: Dependencies from other project packages are often mocked.
-
-### React Component Testing (CLI UI - Ink)
-
-- Use `render()` from `ink-testing-library`.
-- Assert output with `lastFrame()`.
-- Wrap components in necessary `Context.Provider`s.
-- Mock custom React hooks and complex child components using `vi.mock()`.
-
-### Asynchronous Testing
-
-- Use `async/await`.
-- For timers, use `vi.useFakeTimers()`, `vi.advanceTimersByTimeAsync()`, `vi.runAllTimersAsync()`.
-- Test promise rejections with `await expect(promise).rejects.toThrow(...)`.
-
-### General Guidance
-
-- When adding tests, first examine existing tests to understand and conform to established conventions.
-- Pay close attention to the mocks at the top of existing test files; they reveal critical dependencies and how they are managed in a test environment.
-
-## Git Repo
-
-The main branch for this project is called "main"
-
-## JavaScript/TypeScript
-
-When contributing to this React, Node, and TypeScript codebase, please prioritize the use of plain JavaScript objects with accompanying TypeScript interface or type declarations over JavaScript class syntax. This approach offers significant advantages, especially concerning interoperability with React and overall code maintainability.
-
-### Preferring Plain Objects over Classes
-
-JavaScript classes, by their nature, are designed to encapsulate internal state and behavior. While this can be useful in some object-oriented paradigms, it often introduces unnecessary complexity and friction when working with React's component-based architecture. Here's why plain objects are preferred:
-
-- Seamless React Integration: React components thrive on explicit props and state management. Classes' tendency to store internal state directly within instances can make prop and state propagation harder to reason about and maintain. Plain objects, on the other hand, are inherently immutable (when used thoughtfully) and can be easily passed as props, simplifying data flow and reducing unexpected side effects.
-
-- Reduced Boilerplate and Increased Conciseness: Classes often promote the use of constructors, this binding, getters, setters, and other boilerplate that can unnecessarily bloat code. TypeScript interface and type declarations provide powerful static type checking without the runtime overhead or verbosity of class definitions. This allows for more succinct and readable code, aligning with JavaScript's strengths in functional programming.
-
-- Enhanced Readability and Predictability: Plain objects, especially when their structure is clearly defined by TypeScript interfaces, are often easier to read and understand. Their properties are directly accessible, and there's no hidden internal state or complex inheritance chains to navigate. This predictability leads to fewer bugs and a more maintainable codebase.
-
-- Simplified Immutability: While not strictly enforced, plain objects encourage an immutable approach to data. When you need to modify an object, you typically create a new one with the desired changes, rather than mutating the original. This pattern aligns perfectly with React's reconciliation process and helps prevent subtle bugs related to shared mutable state.
-
-- Better Serialization and Deserialization: Plain JavaScript objects are naturally easy to serialize to JSON and deserialize back, which is a common requirement in web development (e.g., for API communication or local storage). Classes, with their methods and prototypes, can complicate this process.
-
-### Embracing ES Module Syntax for Encapsulation
-
-Rather than relying on Java-esque private or public class members, which can be verbose and sometimes limit flexibility, we strongly prefer leveraging ES module syntax (`import`/`export`) for encapsulating private and public APIs.
-
-- Clearer Public API Definition: With ES modules, anything that is exported is part of the public API of that module, while anything not exported is inherently private to that module. This provides a very clear and explicit way to define what parts of your code are meant to be consumed by other modules.
-
-- Enhanced Testability (Without Exposing Internals): By default, unexported functions or variables are not accessible from outside the module. This encourages you to test the public API of your modules, rather than their internal implementation details. If you find yourself needing to spy on or stub an unexported function for testing purposes, it's often a "code smell" indicating that the function might be a good candidate for extraction into its own separate, testable module with a well-defined public API. This promotes a more robust and maintainable testing strategy.
-
-- Reduced Coupling: Explicitly defined module boundaries through import/export help reduce coupling between different parts of your codebase. This makes it easier to refactor, debug, and understand individual components in isolation.
-
-### Avoiding `any` Types and Type Assertions; Preferring `unknown`
-
-TypeScript's power lies in its ability to provide static type checking, catching potential errors before your code runs. To fully leverage this, it's crucial to avoid the `any` type and be judicious with type assertions.
-
-- **The Dangers of `any`**: Using any effectively opts out of TypeScript's type checking for that particular variable or expression. While it might seem convenient in the short term, it introduces significant risks:
-  - **Loss of Type Safety**: You lose all the benefits of type checking, making it easy to introduce runtime errors that TypeScript would otherwise have caught.
-  - **Reduced Readability and Maintainability**: Code with `any` types is harder to understand and maintain, as the expected type of data is no longer explicitly defined.
-  - **Masking Underlying Issues**: Often, the need for any indicates a deeper problem in the design of your code or the way you're interacting with external libraries. It's a sign that you might need to refine your types or refactor your code.
-
-- **Preferring `unknown` over `any`**: When you absolutely cannot determine the type of a value at compile time, and you're tempted to reach for any, consider using unknown instead. unknown is a type-safe counterpart to any. While a variable of type unknown can hold any value, you must perform type narrowing (e.g., using typeof or instanceof checks, or a type assertion) before you can perform any operations on it. This forces you to handle the unknown type explicitly, preventing accidental runtime errors.
-
-  ```
-  function processValue(value: unknown) {
-     if (typeof value === 'string') {
-        // value is now safely a string
-        console.log(value.toUpperCase());
-     } else if (typeof value === 'number') {
-        // value is now safely a number
-        console.log(value * 2);
-     }
-     // Without narrowing, you cannot access properties or methods on 'value'
-     // console.log(value.someProperty); // Error: Object is of type 'unknown'.
-  }
-  ```
-
-- **Type Assertions (`as Type`) - Use with Caution**: Type assertions tell the TypeScript compiler, "Trust me, I know what I'm doing; this is definitely of this type." While there are legitimate use cases (e.g., when dealing with external libraries that don't have perfect type definitions, or when you have more information than the compiler), they should be used sparingly and with extreme caution.
-  - **Bypassing Type Checking**: Like `any`, type assertions bypass TypeScript's safety checks. If your assertion is incorrect, you introduce a runtime error that TypeScript would not have warned you about.
-  - **Code Smell in Testing**: A common scenario where `any` or type assertions might be tempting is when trying to test "private" implementation details (e.g., spying on or stubbing an unexported function within a module). This is a strong indication of a "code smell" in your testing strategy and potentially your code structure. Instead of trying to force access to private internals, consider whether those internal details should be refactored into a separate module with a well-defined public API. This makes them inherently testable without compromising encapsulation.
-
-### Embracing JavaScript's Array Operators
-
-To further enhance code cleanliness and promote safe functional programming practices, leverage JavaScript's rich set of array operators as much as possible. Methods like `.map()`, `.filter()`, `.reduce()`, `.slice()`, `.sort()`, and others are incredibly powerful for transforming and manipulating data collections in an immutable and declarative way.
-
-Using these operators:
-
-- Promotes Immutability: Most array operators return new arrays, leaving the original array untouched. This functional approach helps prevent unintended side effects and makes your code more predictable.
-- Improves Readability: Chaining array operators often lead to more concise and expressive code than traditional for loops or imperative logic. The intent of the operation is clear at a glance.
-- Facilitates Functional Programming: These operators are cornerstones of functional programming, encouraging the creation of pure functions that take inputs and produce outputs without causing side effects. This paradigm is highly beneficial for writing robust and testable code that pairs well with React.
-
-By consistently applying these principles, we can maintain a codebase that is not only efficient and performant but also a joy to work with, both now and in the future.
-
-## React (mirrored and adjusted from [react-mcp-server](https://github.com/facebook/react/blob/4448b18760d867f9e009e810571e7a3b8930bb19/compiler/packages/react-mcp-server/src/index.ts#L376C1-L441C94))
-
-### Role
-
-You are a React assistant that helps users write more efficient and optimizable React code. You specialize in identifying patterns that enable React Compiler to automatically apply optimizations, reducing unnecessary re-renders and improving application performance.
-
-### Follow these guidelines in all code you produce and suggest
-
-Use functional components with Hooks: Do not generate class components or use old lifecycle methods. Manage state with useState or useReducer, and side effects with useEffect (or related Hooks). Always prefer functions and Hooks for any new component logic.
-
-Keep components pure and side-effect-free during rendering: Do not produce code that performs side effects (like subscriptions, network requests, or modifying external variables) directly inside the component's function body. Such actions should be wrapped in useEffect or performed in event handlers. Ensure your render logic is a pure function of props and state.
-
-Respect one-way data flow: Pass data down through props and avoid any global mutations. If two components need to share data, lift that state up to a common parent or use React Context, rather than trying to sync local state or use external variables.
-
-Never mutate state directly: Always generate code that updates state immutably. For example, use spread syntax or other methods to create new objects/arrays when updating state. Do not use assignments like state.someValue = ... or array mutations like array.push() on state variables. Use the state setter (setState from useState, etc.) to update state.
-
-Accurately use useEffect and other effect Hooks: whenever you think you could useEffect, think and reason harder to avoid it. useEffect is primarily only used for synchronization, for example synchronizing React with some external state. IMPORTANT - Don't setState (the 2nd value returned by useState) within a useEffect as that will degrade performance. When writing effects, include all necessary dependencies in the dependency array. Do not suppress ESLint rules or omit dependencies that the effect's code uses. Structure the effect callbacks to handle changing values properly (e.g., update subscriptions on prop changes, clean up on unmount or dependency change). If a piece of logic should only run in response to a user action (like a form submission or button click), put that logic in an event handler, not in a useEffect. Where possible, useEffects should return a cleanup function.
-
-Follow the Rules of Hooks: Ensure that any Hooks (useState, useEffect, useContext, custom Hooks, etc.) are called unconditionally at the top level of React function components or other Hooks. Do not generate code that calls Hooks inside loops, conditional statements, or nested helper functions. Do not call Hooks in non-component functions or outside the React component rendering context.
-
-Use refs only when necessary: Avoid using useRef unless the task genuinely requires it (such as focusing a control, managing an animation, or integrating with a non-React library). Do not use refs to store application state that should be reactive. If you do use refs, never write to or read from ref.current during the rendering of a component (except for initial setup like lazy initialization). Any ref usage should not affect the rendered output directly.
-
-Prefer composition and small components: Break down UI into small, reusable components rather than writing large monolithic components. The code you generate should promote clarity and reusability by composing components together. Similarly, abstract repetitive logic into custom Hooks when appropriate to avoid duplicating code.
-
-Optimize for concurrency: Assume React may render your components multiple times for scheduling purposes (especially in development with Strict Mode). Write code that remains correct even if the component function runs more than once. For instance, avoid side effects in the component body and use functional state updates (e.g., setCount(c => c + 1)) when updating state based on previous state to prevent race conditions. Always include cleanup functions in effects that subscribe to external resources. Don't write useEffects for "do this when this changes" side effects. This ensures your generated code will work with React's concurrent rendering features without issues.
-
-Optimize to reduce network waterfalls - Use parallel data fetching wherever possible (e.g., start multiple requests at once rather than one after another). Leverage Suspense for data loading and keep requests co-located with the component that needs the data. In a server-centric approach, fetch related data together in a single request on the server side (using Server Components, for example) to reduce round trips. Also, consider using caching layers or global fetch management to avoid repeating identical requests.
-
-Rely on React Compiler - useMemo, useCallback, and React.memo can be omitted if React Compiler is enabled. Avoid premature optimization with manual memoization. Instead, focus on writing clear, simple components with direct data flow and side-effect-free render functions. Let the React Compiler handle tree-shaking, inlining, and other performance enhancements to keep your code base simpler and more maintainable.
-
-Design for a good user experience - Provide clear, minimal, and non-blocking UI states. When data is loading, show lightweight placeholders (e.g., skeleton screens) rather than intrusive spinners everywhere. Handle errors gracefully with a dedicated error boundary or a friendly inline message. Where possible, render partial data as it becomes available rather than making the user wait for everything. Suspense allows you to declare the loading states in your component tree in a natural way, preventing “flash” states and improving perceived performance.
-
-### Process
-
-1. Analyze the user's code for optimization opportunities:
-   - Check for React anti-patterns that prevent compiler optimization
-   - Look for component structure issues that limit compiler effectiveness
-   - Think about each suggestion you are making and consult React docs for best practices
-
-2. Provide actionable guidance:
-   - Explain specific code changes with clear reasoning
-   - Show before/after examples when suggesting changes
-   - Only suggest changes that meaningfully improve optimization potential
-
-### Optimization Guidelines
-
-- State updates should be structured to enable granular updates
-- Side effects should be isolated and dependencies clearly defined
-
-## Comments policy
-
-Only write high-value comments if at all. Avoid talking to the user through comments.
-
-## General style requirements
-
-Use hyphens instead of underscores in flag names (e.g. `my-flag` instead of `my_flag`).

README.gemini.md

@@ -1,162 +0,0 @@
-# Gemini CLI
-
-[![Gemini CLI CI](https://github.com/google-gemini/gemini-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/google-gemini/gemini-cli/actions/workflows/ci.yml)
-
-![Gemini CLI Screenshot](./docs/assets/gemini-screenshot.png)
-
-This repository contains the Gemini CLI, a command-line AI workflow tool that connects to your
-tools, understands your code and accelerates your workflows.
-
-With the Gemini CLI you can:
-
-- Query and edit large codebases in and beyond Gemini's 1M token context window.
-- Generate new apps from PDFs or sketches, using Gemini's multimodal capabilities.
-- Automate operational tasks, like querying pull requests or handling complex rebases.
-- Use tools and MCP servers to connect new capabilities, including [media generation with Imagen,
-  Veo or Lyria](https://github.com/GoogleCloudPlatform/vertex-ai-creative-studio/tree/main/experiments/mcp-genmedia)
-- Ground your queries with the [Google Search](https://ai.google.dev/gemini-api/docs/grounding)
-  tool, built in to Gemini.
-
-## Quickstart
-
-1. **Prerequisites:** Ensure you have [Node.js version 20](https://nodejs.org/en/download) or higher installed.
-2. **Run the CLI:** Execute the following command in your terminal:
-
-   ```bash
-   npx https://github.com/google-gemini/gemini-cli
-   ```
-
-   Or install it with:
-
-   ```bash
-   npm install -g @google/gemini-cli
-   ```
-
-   Then, run the CLI from anywhere:
-
-   ```bash
-   gemini
-   ```
-
-3. **Pick a color theme**
-4. **Authenticate:** When prompted, sign in with your personal Google account. This will grant you up to 60 model requests per minute and 1,000 model requests per day using Gemini.
-
-You are now ready to use the Gemini CLI!
-
-### Use a Gemini API key:
-
-The Gemini API provides a free tier with [100 requests per day](https://ai.google.dev/gemini-api/docs/rate-limits#free-tier) using Gemini 2.5 Pro, control over which model you use, and access to higher rate limits (with a paid plan):
-
-1. Generate a key from [Google AI Studio](https://aistudio.google.com/apikey).
-2. Set it as an environment variable in your terminal. Replace `YOUR_API_KEY` with your generated key.
-
-   ```bash
-   export GEMINI_API_KEY="YOUR_API_KEY"
-   ```
-
-3. (Optionally) Upgrade your Gemini API project to a paid plan on the API key page (will automatically unlock [Tier 1 rate limits](https://ai.google.dev/gemini-api/docs/rate-limits#tier-1))
-
-### Use a Vertex AI API key:
-
-The Vertex AI API provides a [free tier](https://cloud.google.com/vertex-ai/generative-ai/docs/start/express-mode/overview) using express mode for Gemini 2.5 Pro, control over which model you use, and access to higher rate limits with a billing account:
-
-1. Generate a key from [Google Cloud](https://cloud.google.com/vertex-ai/generative-ai/docs/start/api-keys).
-2. Set it as an environment variable in your terminal. Replace `YOUR_API_KEY` with your generated key and set GOOGLE_GENAI_USE_VERTEXAI to true
-
-   ```bash
-   export GOOGLE_API_KEY="YOUR_API_KEY"
-   export GOOGLE_GENAI_USE_VERTEXAI=true
-   ```
-
-3. (Optionally) Add a billing account on your project to get access to [higher usage limits](https://cloud.google.com/vertex-ai/generative-ai/docs/quotas)
-
-For other authentication methods, including Google Workspace accounts, see the [authentication](./docs/cli/authentication.md) guide.
-
-## Examples
-
-Once the CLI is running, you can start interacting with Gemini from your shell.
-
-You can start a project from a new directory:
-
-```sh
-cd new-project/
-gemini
-> Write me a Gemini Discord bot that answers questions using a FAQ.md file I will provide
-```
-
-Or work with an existing project:
-
-```sh
-git clone https://github.com/google-gemini/gemini-cli
-cd gemini-cli
-gemini
-> Give me a summary of all of the changes that went in yesterday
-```
-
-### Next steps
-
-- Learn how to [contribute to or build from the source](./CONTRIBUTING.md).
-- Explore the available **[CLI Commands](./docs/cli/commands.md)**.
-- If you encounter any issues, review the **[troubleshooting guide](./docs/troubleshooting.md)**.
-- For more comprehensive documentation, see the [full documentation](./docs/index.md).
-- Take a look at some [popular tasks](#popular-tasks) for more inspiration.
-- Check out our **[Official Roadmap](./ROADMAP.md)**
-
-### Troubleshooting
-
-Head over to the [troubleshooting guide](docs/troubleshooting.md) if you're
-having issues.
-
-## Popular tasks
-
-### Explore a new codebase
-
-Start by `cd`ing into an existing or newly-cloned repository and running `gemini`.
-
-```text
-> Describe the main pieces of this system's architecture.
-```
-
-```text
-> What security mechanisms are in place?
-```
-
-### Work with your existing code
-
-```text
-> Implement a first draft for GitHub issue #123.
-```
-
-```text
-> Help me migrate this codebase to the latest version of Java. Start with a plan.
-```
-
-### Automate your workflows
-
-Use MCP servers to integrate your local system tools with your enterprise collaboration suite.
-
-```text
-> Make me a slide deck showing the git history from the last 7 days, grouped by feature and team member.
-```
-
-```text
-> Make a full-screen web app for a wall display to show our most interacted-with GitHub issues.
-```
-
-### Interact with your system
-
-```text
-> Convert all the images in this directory to png, and rename them to use dates from the exif data.
-```
-
-```text
-> Organize my PDF invoices by month of expenditure.
-```
-
-### Uninstall
-
-Head over to the [Uninstall](docs/Uninstall.md) guide for uninstallation instructions.
-
-## Terms of Service and Privacy Notice
-
-For details on the terms of service and privacy notice applicable to your use of Gemini CLI, see the [Terms of Service and Privacy Notice](./docs/tos-privacy.md).

README.md

@@ -2,7 +2,7 @@
 
 <div align="center">
 
-![Qwen Code Screenshot](./docs/assets/qwen-screenshot.png)
+![](https://gw.alicdn.com/imgextra/i1/O1CN01D2DviS1wwtEtMwIzJ_!!6000000006373-2-tps-1600-900.png)
 
 [![npm version](https://img.shields.io/npm/v/@qwen-code/qwen-code.svg)](https://www.npmjs.com/package/@qwen-code/qwen-code)
 [![License](https://img.shields.io/github/license/QwenLM/qwen-code.svg)](./LICENSE)
@@ -11,41 +11,36 @@
 
 **AI-powered command-line workflow tool for developers**
 
-[Installation](#installation) • [Quick Start](#quick-start) • [Features](#key-features) • [Documentation](./docs/) • [Contributing](./CONTRIBUTING.md)
+  <a href="https://qwenlm.github.io/qwen-code-docs/zh/">中文</a> |
+  <a href="https://qwenlm.github.io/qwen-code-docs/de/">Deutsch</a> | 
+  <a href="https://qwenlm.github.io/qwen-code-docs/fr">français</a> | 
+  <a href="https://qwenlm.github.io/qwen-code-docs/ja/">日本語</a> | 
+  <a href="https://qwenlm.github.io/qwen-code-docs/ru">Русский</a> 
+
+[Installation](#install-from-npm) • [Quick Start](#-quick-start) • [Features](#-why-qwen-code) • [Documentation](https://qwenlm.github.io/qwen-code-docs/en/users/overview/) • [Contributing](https://qwenlm.github.io/qwen-code-docs/en/developers/contributing/)
+
 
 </div>
 
-Qwen Code is a powerful command-line AI workflow tool adapted from [**Gemini CLI**](https://github.com/google-gemini/gemini-cli) ([details](./README.gemini.md)), specifically optimized for [Qwen3-Coder](https://github.com/QwenLM/Qwen3-Coder) models. It enhances your development workflow with advanced code understanding, automated tasks, and intelligent assistance.
+Qwen Code is a powerful command-line AI workflow tool adapted from [**Gemini CLI**](https://github.com/google-gemini/gemini-cli), specifically optimized for [Qwen3-Coder](https://github.com/QwenLM/Qwen3-Coder) models. It enhances your development workflow with advanced code understanding, automated tasks, and intelligent assistance.
 
-## 💡 Free Options Available
 
-Get started with Qwen Code at no cost using any of these free options:
 
-### 🔥 Qwen OAuth (Recommended)
+## 📌 Why Qwen Code？
 
-- **2,000 requests per day** with no token limits
-- **60 requests per minute** rate limit
-- Simply run `qwen` and authenticate with your qwen.ai account
-- Automatic credential management and refresh
-- Use `/auth` command to switch to Qwen OAuth if you have initialized with OpenAI compatible mode
+- 🎯 Free Access Available: Get started with 2,000 free requests per day via Qwen OAuth.
+- 🧠 Code Understanding & Editing - Query and edit large codebases beyond traditional context window limits
+- 🤖 Workflow Automation - Automate operational tasks like handling pull requests and complex rebases
+- 💻 Terminal-first: Designed for developers who live in the command line.
+- 🧰 VS Code: Install the VS Code extension to seamlessly integrate into your existing workflow.
+- 📦 Simple Setup: Easy installation with npm, Homebrew, or source for quick deployment.
 
-### 🌏 Regional Free Tiers
+>👉 Know more [workflows](https://qwenlm.github.io/qwen-code-docs/en/users/common-workflow/)
+>
+> 📦 The extension is currently in development. For installation, features, and development guide, see the [VS Code Extension README](./packages/vscode-ide-companion/README.md).
 
-- **Mainland China**: ModelScope offers **2,000 free API calls per day**
-- **International**: OpenRouter provides **up to 1,000 free API calls per day** worldwide
 
-For detailed setup instructions, see [Authorization](#authorization).
-
-> [!WARNING]
-> **Token Usage Notice**: Qwen Code may issue multiple API calls per cycle, resulting in higher token usage (similar to Claude Code). We're actively optimizing API efficiency.
-
-## Key Features
-
-- **Code Understanding & Editing** - Query and edit large codebases beyond traditional context window limits
-- **Workflow Automation** - Automate operational tasks like handling pull requests and complex rebases
-- **Enhanced Parser** - Adapted parser specifically optimized for Qwen-Coder models
-
-## Installation
+## ❓ How to use Qwen Code?
 
 ### Prerequisites
 
@@ -59,249 +54,57 @@ curl -qL https://www.npmjs.com/install.sh | sh
 
 ```bash
 npm install -g @qwen-code/qwen-code@latest
-qwen --version
 ```
 
-### Install from source
-
-```bash
-git clone https://github.com/QwenLM/qwen-code.git
-cd qwen-code
-npm install
-npm install -g .
-```
-
-## Quick Start
+## 🚀 Quick Start
 
 ```bash
 # Start Qwen Code
 qwen
 
 # Example commands
+> What does this project do?
 > Explain this codebase structure
 > Help me refactor this function
 > Generate unit tests for this module
 ```
 
-### Session Management
+👇 Click to play video
 
-Control your token usage with configurable session limits to optimize costs and performance.
+[![qwencode-start](https://img.alicdn.com/imgextra/i3/6000000004682/O1CN01cSWkqj1kSPUZPj68h_!!6000000004682-0-tbvideo.jpg)](https://cloud.video.taobao.com/vod/HLfyppnCHplRV9Qhz2xSqeazHeRzYtG-EYJnHAqtzkQ.mp4)
 
-#### Configure Session Token Limit
-
-Create or edit `.qwen/settings.json` in your home directory:
-
-```json
-{
-  "sessionTokenLimit": 32000
-}
-```
-
-#### Session Commands
-
-- **`/compress`** - Compress conversation history to continue within token limits
-- **`/clear`** - Clear all conversation history and start fresh
-- **`/status`** - Check current token usage and limits
-
-> 📝 **Note**: Session token limit applies to a single conversation, not cumulative API calls.
-
-### Authorization
-
-Choose your preferred authentication method based on your needs:
-
-#### 1. Qwen OAuth (🚀 Recommended - Start in 30 seconds)
-
-The easiest way to get started - completely free with generous quotas:
-
-```bash
-# Just run this command and follow the browser authentication
-qwen
-```
-
-**What happens:**
-
-1. **Instant Setup**: CLI opens your browser automatically
-2. **One-Click Login**: Authenticate with your qwen.ai account
-3. **Automatic Management**: Credentials cached locally for future use
-4. **No Configuration**: Zero setup required - just start coding!
-
-**Free Tier Benefits:**
-
-- ✅ **2,000 requests/day** (no token counting needed)
-- ✅ **60 requests/minute** rate limit
-- ✅ **Automatic credential refresh**
-- ✅ **Zero cost** for individual users
-- ℹ️ **Note**: Model fallback may occur to maintain service quality
-
-#### 2. OpenAI-Compatible API
-
-Use API keys for OpenAI or other compatible providers:
-
-**Configuration Methods:**
-
-1. **Environment Variables**
-
-   ```bash
-   export OPENAI_API_KEY="your_api_key_here"
-   export OPENAI_BASE_URL="your_api_endpoint"
-   export OPENAI_MODEL="your_model_choice"
-   ```
-
-2. **Project `.env` File**
-   Create a `.env` file in your project root:
-   ```env
-   OPENAI_API_KEY=your_api_key_here
-   OPENAI_BASE_URL=your_api_endpoint
-   OPENAI_MODEL=your_model_choice
-   ```
-
-**API Provider Options**
-
-> ⚠️ **Regional Notice:**
->
-> - **Mainland China**: Use Alibaba Cloud Bailian or ModelScope
-> - **International**: Use Alibaba Cloud ModelStudio or OpenRouter
-
-<details>
-<summary><b>🇨🇳 For Users in Mainland China</b></summary>
-
-**Option 1: Alibaba Cloud Bailian** ([Apply for API Key](https://bailian.console.aliyun.com/))
-
-```bash
-export OPENAI_API_KEY="your_api_key_here"
-export OPENAI_BASE_URL="https://dashscope.aliyuncs.com/compatible-mode/v1"
-export OPENAI_MODEL="qwen3-coder-plus"
-```
-
-**Option 2: ModelScope (Free Tier)** ([Apply for API Key](https://modelscope.cn/docs/model-service/API-Inference/intro))
-
-- ✅ **2,000 free API calls per day**
-- ⚠️ Connect your Aliyun account to avoid authentication errors
-
-```bash
-export OPENAI_API_KEY="your_api_key_here"
-export OPENAI_BASE_URL="https://api-inference.modelscope.cn/v1"
-export OPENAI_MODEL="Qwen/Qwen3-Coder-480B-A35B-Instruct"
-```
-
-</details>
-
-<details>
-<summary><b>🌍 For International Users</b></summary>
-
-**Option 1: Alibaba Cloud ModelStudio** ([Apply for API Key](https://modelstudio.console.alibabacloud.com/))
-
-```bash
-export OPENAI_API_KEY="your_api_key_here"
-export OPENAI_BASE_URL="https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
-export OPENAI_MODEL="qwen3-coder-plus"
-```
-
-**Option 2: OpenRouter (Free Tier Available)** ([Apply for API Key](https://openrouter.ai/))
-
-```bash
-export OPENAI_API_KEY="your_api_key_here"
-export OPENAI_BASE_URL="https://openrouter.ai/api/v1"
-export OPENAI_MODEL="qwen/qwen3-coder:free"
-```
-
-</details>
 
 ## Usage Examples
 
-### 🔍 Explore Codebases
+### 1️⃣ Interactive Mode
 
 ```bash
 cd your-project/
 qwen
-
-# Architecture analysis
-> Describe the main pieces of this system's architecture
-> What are the key dependencies and how do they interact?
-> Find all API endpoints and their authentication methods
 ```
 
-### 💻 Code Development
+Navigate to your project folder and type `qwen` to launch Qwen Code. Start a conversation and use `@` to reference files within the folder.
+
+If you want to learn more about common workflows, click [Common Workflows](https://qwenlm.github.io/qwen-code-docs/en/users/common-workflow/) to view.
+
+### 2️⃣ Headless Mode
 
 ```bash
-# Refactoring
-> Refactor this function to improve readability and performance
-> Convert this class to use dependency injection
-> Split this large module into smaller, focused components
-
-# Code generation
-> Create a REST API endpoint for user management
-> Generate unit tests for the authentication module
-> Add error handling to all database operations
+cd your-project/
+qwen -p "your question"
 ```
+[Headless mode](https://qwenlm.github.io/qwen-code-docs/en/users/features/headless) allows you to run Qwen Code programmatically from command line scripts and automation tools without any interactive UI. This is ideal for scripting, automation, CI/CD pipelines, and building AI-powered tools.
 
-### 🔄 Automate Workflows
+### 3️⃣ Use in IDE
+If you prefer to integrate Qwen Code into your current editor, we now support VS Code and Zed. For details, please refer to:
 
-```bash
-# Git automation
-> Analyze git commits from the last 7 days, grouped by feature
-> Create a changelog from recent commits
-> Find all TODO comments and create GitHub issues
+- [Use in VS Code](https://qwenlm.github.io/qwen-code-docs/en/users/integration-vscode/)
+- [Use in Zed](https://qwenlm.github.io/qwen-code-docs/en/users/integration-zed/)
 
-# File operations
-> Convert all images in this directory to PNG format
-> Rename all test files to follow the *.test.ts pattern
-> Find and remove all console.log statements
-```
+### 4️⃣ SDK
+Qwen Code now supports an SDK designed to simplify integration with the Qwen Code platform. It provides a set of easy-to-use APIs and tools enabling developers to efficiently build, test, and deploy applications. For details, please refer to:
 
-### 🐛 Debugging & Analysis
-
-```bash
-# Performance analysis
-> Identify performance bottlenecks in this React component
-> Find all N+1 query problems in the codebase
-
-# Security audit
-> Check for potential SQL injection vulnerabilities
-> Find all hardcoded credentials or API keys
-```
-
-## Popular Tasks
-
-### 📚 Understand New Codebases
-
-```text
-> What are the core business logic components?
-> What security mechanisms are in place?
-> How does the data flow through the system?
-> What are the main design patterns used?
-> Generate a dependency graph for this module
-```
-
-### 🔨 Code Refactoring & Optimization
-
-```text
-> What parts of this module can be optimized?
-> Help me refactor this class to follow SOLID principles
-> Add proper error handling and logging
-> Convert callbacks to async/await pattern
-> Implement caching for expensive operations
-```
-
-### 📝 Documentation & Testing
-
-```text
-> Generate comprehensive JSDoc comments for all public APIs
-> Write unit tests with edge cases for this component
-> Create API documentation in OpenAPI format
-> Add inline comments explaining complex algorithms
-> Generate a README for this module
-```
-
-### 🚀 Development Acceleration
-
-```text
-> Set up a new Express server with authentication
-> Create a React component with TypeScript and tests
-> Implement a rate limiter middleware
-> Add database migrations for new schema
-> Configure CI/CD pipeline for this project
-```
+- [Use the Qwen Code SDK](./packages/sdk-typescript/README.md)
 
 ## Commands & Shortcuts
 
@@ -310,7 +113,7 @@ qwen
 - `/help` - Display available commands
 - `/clear` - Clear conversation history
 - `/compress` - Compress history to save tokens
-- `/status` - Show current session information
+- `/stats` - Show current session information
 - `/exit` or `/quit` - Exit Qwen Code
 
 ### Keyboard Shortcuts
@@ -319,6 +122,11 @@ qwen
 - `Ctrl+D` - Exit (on empty line)
 - `Up/Down` - Navigate command history
 
+
+> 👉 Know more about [Commands](https://qwenlm.github.io/qwen-code-docs/en/users/features/commands/)
+>
+> 💡 **Tip**: In YOLO mode (`--yolo`), vision switching happens automatically without prompts when images are detected. Know more about [Approval Mode](https://qwenlm.github.io/qwen-code-docs/en/users/features/approval-mode/)
+
 ## Benchmark Results
 
 ### Terminal-Bench Performance
@@ -330,13 +138,13 @@ qwen
 
 ## Development & Contributing
 
-See [CONTRIBUTING.md](./CONTRIBUTING.md) to learn how to contribute to the project.
+See [CONTRIBUTING.md](https://qwenlm.github.io/qwen-code-docs/en/developers/contributing/) to learn how to contribute to the project.
 
-For detailed authentication setup, see the [authentication guide](./docs/cli/authentication.md).
+For detailed authentication setup, see the [authentication guide](https://qwenlm.github.io/qwen-code-docs/en/users/configuration/auth/).
 
 ## Troubleshooting
 
-If you encounter issues, check the [troubleshooting guide](docs/troubleshooting.md).
+If you encounter issues, check the [troubleshooting guide](https://qwenlm.github.io/qwen-code-docs/en/users/support/troubleshooting/).
 
 ## Acknowledgments
 

ROADMAP.md

@@ -1,63 +0,0 @@
-# Qwen CLI Roadmap
-
-The [Official Gemini CLI Roadmap](https://github.com/orgs/google-gemini/projects/11/)
-
-Gemini CLI is an open-source AI agent that brings the power of Gemini directly into your terminal. It provides lightweight access to Gemini, giving you the most direct path from your prompt to our model.
-
-This document outlines our approach to the Gemini CLI roadmap. Here, you'll find our guiding principles and a breakdown of the key areas we are
-focused on for development. Our roadmap is not a static list but a dynamic set of priorities that are tracked live in our GitHub Issues.
-
-As an [Apache 2.0 open source project](https://github.com/google-gemini/gemini-cli?tab=Apache-2.0-1-ov-file#readme), we appreciate and welcome [public contributions](https://github.com/google-gemini/gemini-cli/blob/main/CONTRIBUTING.md), and will give first priority to those contributions aligned with our roadmap. If you want to propose a new feature or change to our roadmap, please start by [opening an issue for discussion](https://github.com/google-gemini/gemini-cli/issues/new/choose).
-
-## Disclaimer
-
-This roadmap represents our current thinking and is for informational purposes only. It is not a commitment or a guarantee of future delivery. The development, release, and timing of any features are subject to change, and we may update the roadmap based on community discussions as well as when our priorities evolve.
-
-## Guiding Principles
-
-Our development is guided by the following principles:
-
-- **Power & Simplicity:** Deliver access to state-of-the-art Gemini models with an intuitive and easy-to-use lightweight command-line interface.
-- **Extensibility:** An adaptable agent to help you with a variety of use cases and environments along with the ability to run these agents anywhere.
-- **Intelligent:** Gemini CLI should be reliably ranked among the best agentic tools as measured by benchmarks like SWE Bench, Terminal Bench, and CSAT.
-- **Free and Open Source:** Foster a thriving open source community where cost isn’t a barrier to personal use, and PRs get merged quickly. This means resolving and closing issues, pull requests, and discussion posts quickly.
-
-## How the Roadmap Works
-
-Our roadmap is managed directly through Github Issues. See our entry point Roadmap Issue [here](https://github.com/google-gemini/gemini-cli/issues/4191). This approach allows for transparency and gives you a direct way to learn more or get involved with any specific initiative. All our roadmap items will be tagged as Type:`Feature` and Label:`maintainer` for features we are actively working on, or Type:`Task` and Label:`maintainer` for a more detailed list of tasks.
-
-Issues are organized to provide key information at a glance:
-
-- **Target Quarter:** `Milestone` denotes the anticipated delivery timeline.
-- **Feature Area:** Labels such as `area/model` or `area/tooling` categorizes the work.
-- **Issue Type:** _Workstream_ => _Epics_ => _Features_ => _Tasks|Bugs_
-
-To see what we're working on, you can filter our issues by these dimensions. See all our items [here](https://github.com/orgs/google-gemini/projects/11/views/19)
-
-## Focus Areas
-
-To better organize our efforts, we categorize our work into several key feature areas. These labels are used on our GitHub Issues to help you filter and
-find initiatives that interest you.
-
-- **Authentication:** Secure user access via API keys, Gemini Code Assist login etc.
-- **Model:** Support new Gemini models, multi-modality, local execution, and performance tuning.
-- **User Experience:** Improve the CLI's usability, performance, interactive features, and documentation.
-- **Tooling:** Built-in tools and the MCP ecosystem.
-- **Core:** Core functionality of the CLI
-- **Extensibility:** Bringing Gemini CLI to other surfaces e.g. GitHub.
-- **Contribution:** Improve the contribution process via test automation and CI/CD pipeline enhancements.
-- **Platform:** Manage installation, OS support, and the underlying CLI framework.
-- **Quality:** Focus on testing, reliability, performance, and overall product quality.
-- **Background Agents:** Enable long-running, autonomous tasks and proactive assistance.
-- **Security and Privacy:** For all things related to security and privacy
-
-## How to Contribute
-
-Gemini CLI is an open-source project, and we welcome contributions from the community! Whether you're a developer, a designer, or just an enthusiastic user you can find our [Community Guidelines here](https://github.com/google-gemini/gemini-cli/blob/main/CONTRIBUTING.md) to learn how to get started. There are many ways to get involved:
-
-- **Roadmap:** Please review and find areas in our [roadmap](https://github.com/google-gemini/gemini-cli/issues/4191) that you would like to contribute to. Contributions based on this will be easiest to integrate with.
-- **Report Bugs:** If you find an issue, please create a bug(https://github.com/google-gemini/gemini-cli/issues/new?template=bug_report.yml) with as much detail as possible. If you believe it is a critical breaking issue preventing direct CLI usage, please tag it as `priorty/p0`.
-- **Suggest Features:** Have a great idea? We'd love to hear it! Open a [feature request](https://github.com/google-gemini/gemini-cli/issues/new?template=feature_request.yml).
-- **Contribute Code:** Check out our [CONTRIBUTING.md](https://github.com/google-gemini/gemini-cli/blob/main/CONTRIBUTING.md) file for guidelines on how to submit pull requests. We have a list of "good first issues" for new contributors.
-- **Write Documentation:** Help us improve our documentation, tutorials, and examples.
-  We are excited about the future of Gemini CLI and look forward to building it with you!

SECURITY.md

@@ -1,8 +1,5 @@
 # Reporting Security Issues
 
-To report a security issue, please use [https://g.co/vulnz](https://g.co/vulnz).
-We use g.co/vulnz for our intake, and do coordination and disclosure here on
-GitHub (including using GitHub Security Advisory). The Google Security Team will
-respond within 5 working days of your report on g.co/vulnz.
+Please report any security issue or Higress crash report to [ASRC](https://security.alibaba.com/) (Alibaba Security Response Center) where the issue will be triaged appropriately.
 
-[GitHub Security Advisory]: https://github.com/google-gemini/gemini-cli/security/advisories
+Thank you for helping keep our project secure.

docs-site/README.md

@@ -0,0 +1,54 @@
+# Qwen Code Docs Site
+
+A documentation website for Qwen Code built with [Next.js](https://nextjs.org/) and [Nextra](https://nextra.site/).
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js 18+
+- npm or yarn
+
+### Installation
+
+```bash
+npm install
+```
+
+### Setup Content
+
+Link the documentation content from the parent `docs` directory:
+
+```bash
+npm run link
+```
+
+This creates a symbolic link from `../docs` to `content` in the project.
+
+### Development
+
+Start the development server:
+
+```bash
+npm run dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) in your browser to see the documentation site.
+
+## Project Structure
+
+```
+docs-site/
+├── src/
+│   └── app/
+│       ├── [[...mdxPath]]/    # Dynamic routing for MDX pages
+│       │   └── page.jsx
+│       └── layout.jsx          # Root layout with navbar and footer
+├── mdx-components.js           # MDX component configuration
+├── next.config.mjs             # Next.js configuration
+└── package.json
+```
+
+## License
+
+MIT © Qwen Team

docs-site/mdx-components.js

@@ -0,0 +1,12 @@
+import { useMDXComponents as getThemeComponents } from 'nextra-theme-docs'; // nextra-theme-blog or your custom theme
+
+// Get the default MDX components
+const themeComponents = getThemeComponents();
+
+// Merge components
+export function useMDXComponents(components) {
+  return {
+    ...themeComponents,
+    ...components,
+  };
+}

docs-site/next-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+import './.next/dev/types/routes.d.ts';
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

docs-site/next.config.mjs

@@ -0,0 +1,5 @@
+import nextra from 'nextra';
+
+const withNextra = nextra({});
+
+export default withNextra({});

docs-site/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "docs-site",
+  "version": "1.0.0",
+  "description": "",
+  "license": "ISC",
+  "author": "",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "link": "ln -s ../docs content",
+    "clean": "rm -rf .next",
+    "dev": "npm run clean && next --turbopack",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "next": "^16.0.8",
+    "nextra": "^4.6.1",
+    "nextra-theme-docs": "^4.6.1",
+    "react": "^19.2.1",
+    "react-dom": "^19.2.1"
+  }
+}

docs-site/src/app/[[...mdxPath]]/page.jsx

@@ -0,0 +1,27 @@
+import { generateStaticParamsFor, importPage } from 'nextra/pages';
+import { useMDXComponents as getMDXComponents } from '../../../mdx-components';
+
+export const generateStaticParams = generateStaticParamsFor('mdxPath');
+
+export async function generateMetadata(props) {
+  const params = await props.params;
+  const { metadata } = await importPage(params.mdxPath);
+  return metadata;
+}
+
+const Wrapper = getMDXComponents().wrapper;
+
+export default async function Page(props) {
+  const params = await props.params;
+  const {
+    default: MDXContent,
+    toc,
+    metadata,
+    sourceCode,
+  } = await importPage(params.mdxPath);
+  return (
+    <Wrapper toc={toc} metadata={metadata} sourceCode={sourceCode}>
+      <MDXContent {...props} params={params} />
+    </Wrapper>
+  );
+}

docs-site/src/app/layout.jsx

@@ -0,0 +1,55 @@
+import { Footer, Layout, Navbar } from 'nextra-theme-docs';
+import { Banner, Head } from 'nextra/components';
+import { getPageMap } from 'nextra/page-map';
+import 'nextra-theme-docs/style.css';
+
+export const metadata = {
+  // Define your metadata here
+  // For more information on metadata API, see: https://nextjs.org/docs/app/building-your-application/optimizing/metadata
+};
+
+const banner = (
+  <Banner storageKey="some-key">Qwen Code 0.5.0 is released 🎉</Banner>
+);
+const navbar = (
+  <Navbar
+    logo={<b>Qwen Code</b>}
+    // ... Your additional navbar options
+  />
+);
+const footer = <Footer>MIT {new Date().getFullYear()} © Qwen Team.</Footer>;
+
+export default async function RootLayout({ children }) {
+  return (
+    <html
+      // Not required, but good for SEO
+      lang="en"
+      // Required to be set
+      dir="ltr"
+      // Suggested by `next-themes` package https://github.com/pacocoursey/next-themes#with-app
+      suppressHydrationWarning
+    >
+      <Head
+      // ... Your additional head options
+      >
+        {/* Your additional tags should be passed as `children` of `<Head>` element */}
+      </Head>
+      <body>
+        <Layout
+          banner={banner}
+          navbar={navbar}
+          pageMap={await getPageMap()}
+          docsRepositoryBase="https://github.com/QwenLM/qwen-code/docs"
+          // Use a very large finite integer to expand all folders by default.
+          // (Some schema validators reject `Infinity`.)
+          sidebar={{ defaultMenuCollapseLevel: 9999 }}
+          footer={footer}
+          search={false}
+          // ... Your additional layout options
+        >
+          {children}
+        </Layout>
+      </body>
+    </html>
+  );
+}

docs/_meta.ts

@@ -0,0 +1,14 @@
+export default {
+  index: {
+    type: 'page',
+    display: 'hidden',
+  },
+  users: {
+    type: 'page',
+    title: 'User Guide',
+  },
+  developers: {
+    type: 'page',
+    title: 'Developer Guide',
+  },
+};

docs/architecture.md

@@ -1,54 +0,0 @@
-# Gemini CLI Architecture Overview
-
-This document provides a high-level overview of the Gemini CLI's architecture.
-
-## Core components
-
-The Gemini CLI is primarily composed of two main packages, along with a suite of tools that can be used by the system in the course of handling command-line input:
-
-1.  **CLI package (`packages/cli`):**
-    - **Purpose:** This contains the user-facing portion of the Gemini CLI, such as handling the initial user input, presenting the final output, and managing the overall user experience.
-    - **Key functions contained in the package:**
-      - [Input processing](./cli/commands.md)
-      - History management
-      - Display rendering
-      - [Theme and UI customization](./cli/themes.md)
-      - [CLI configuration settings](./cli/configuration.md)
-
-2.  **Core package (`packages/core`):**
-    - **Purpose:** This acts as the backend for the Gemini CLI. It receives requests sent from `packages/cli`, orchestrates interactions with the Gemini API, and manages the execution of available tools.
-    - **Key functions contained in the package:**
-      - API client for communicating with the Google Gemini API
-      - Prompt construction and management
-      - Tool registration and execution logic
-      - State management for conversations or sessions
-      - Server-side configuration
-
-3.  **Tools (`packages/core/src/tools/`):**
-    - **Purpose:** These are individual modules that extend the capabilities of the Gemini model, allowing it to interact with the local environment (e.g., file system, shell commands, web fetching).
-    - **Interaction:** `packages/core` invokes these tools based on requests from the Gemini model.
-
-## Interaction Flow
-
-A typical interaction with the Gemini CLI follows this flow:
-
-1.  **User input:** The user types a prompt or command into the terminal, which is managed by `packages/cli`.
-2.  **Request to core:** `packages/cli` sends the user's input to `packages/core`.
-3.  **Request processed:** The core package:
-    - Constructs an appropriate prompt for the Gemini API, possibly including conversation history and available tool definitions.
-    - Sends the prompt to the Gemini API.
-4.  **Gemini API response:** The Gemini API processes the prompt and returns a response. This response might be a direct answer or a request to use one of the available tools.
-5.  **Tool execution (if applicable):**
-    - When the Gemini API requests a tool, the core package prepares to execute it.
-    - If the requested tool can modify the file system or execute shell commands, the user is first given details of the tool and its arguments, and the user must approve the execution.
-    - Read-only operations, such as reading files, might not require explicit user confirmation to proceed.
-    - Once confirmed, or if confirmation is not required, the core package executes the relevant action within the relevant tool, and the result is sent back to the Gemini API by the core package.
-    - The Gemini API processes the tool result and generates a final response.
-6.  **Response to CLI:** The core package sends the final response back to the CLI package.
-7.  **Display to user:** The CLI package formats and displays the response to the user in the terminal.
-
-## Key Design Principles
-
-- **Modularity:** Separating the CLI (frontend) from the Core (backend) allows for independent development and potential future extensions (e.g., different frontends for the same backend).
-- **Extensibility:** The tool system is designed to be extensible, allowing new capabilities to be added.
-- **User experience:** The CLI focuses on providing a rich and interactive terminal experience.

docs/cli/authentication.md

@@ -1,143 +0,0 @@
-# Authentication Setup
-
-Qwen Code supports two main authentication methods to access AI models. Choose the method that best fits your use case:
-
-1.  **Qwen OAuth (Recommended):**
-    - Use this option to log in with your qwen.ai account.
-    - During initial startup, Qwen Code will direct you to the qwen.ai authentication page. Once authenticated, your credentials will be cached locally so the web login can be skipped on subsequent runs.
-    - **Requirements:**
-      - Valid qwen.ai account
-      - Internet connection for initial authentication
-    - **Benefits:**
-      - Seamless access to Qwen models
-      - Automatic credential refresh
-      - No manual API key management required
-
-    **Getting Started:**
-
-    ```bash
-    # Start Qwen Code and follow the OAuth flow
-    qwen
-    ```
-
-    The CLI will automatically open your browser and guide you through the authentication process.
-
-    **For users who authenticate using their qwen.ai account:**
-
-    **Quota:**
-    - 60 requests per minute
-    - 2,000 requests per day
-    - Token usage is not applicable
-
-    **Cost:** Free
-
-    **Notes:** A specific quota for different models is not specified; model fallback may occur to preserve shared experience quality.
-
-2.  **<a id="openai-api"></a>OpenAI-Compatible API:**
-    - Use API keys for OpenAI or other compatible providers.
-    - This method allows you to use various AI models through API keys.
-
-    **Configuration Methods:**
-
-    a) **Environment Variables:**
-
-    ```bash
-    export OPENAI_API_KEY="your_api_key_here"
-    export OPENAI_BASE_URL="your_api_endpoint"  # Optional
-    export OPENAI_MODEL="your_model_choice"     # Optional
-    ```
-
-    b) **Project `.env` File:**
-    Create a `.env` file in your project root:
-
-    ```env
-    OPENAI_API_KEY=your_api_key_here
-    OPENAI_BASE_URL=your_api_endpoint
-    OPENAI_MODEL=your_model_choice
-    ```
-
-    **Supported Providers:**
-    - OpenAI (https://platform.openai.com/api-keys)
-    - Alibaba Cloud Bailian
-    - ModelScope
-    - OpenRouter
-    - Azure OpenAI
-    - Any OpenAI-compatible API
-
-## Switching Authentication Methods
-
-To switch between authentication methods during a session, use the `/auth` command in the CLI interface:
-
-```bash
-# Within the CLI, type:
-/auth
-```
-
-This will allow you to reconfigure your authentication method without restarting the application.
-
-### Persisting Environment Variables with `.env` Files
-
-You can create a **`.qwen/.env`** file in your project directory or in your home directory. Creating a plain **`.env`** file also works, but `.qwen/.env` is recommended to keep Qwen Code variables isolated from other tools.
-
-**Important:** Some environment variables (like `DEBUG` and `DEBUG_MODE`) are automatically excluded from project `.env` files to prevent interference with qwen-code behavior. Use `.qwen/.env` files for qwen-code specific variables.
-
-Qwen Code automatically loads environment variables from the **first** `.env` file it finds, using the following search order:
-
-1. Starting in the **current directory** and moving upward toward `/`, for each directory it checks:
-   1. `.qwen/.env`
-   2. `.env`
-2. If no file is found, it falls back to your **home directory**:
-   - `~/.qwen/.env`
-   - `~/.env`
-
-> **Important:** The search stops at the **first** file encountered—variables are **not merged** across multiple files.
-
-#### Examples
-
-**Project-specific overrides** (take precedence when you are inside the project):
-
-```bash
-mkdir -p .qwen
-cat >> .qwen/.env <<'EOF'
-OPENAI_API_KEY="your-api-key"
-OPENAI_BASE_URL="https://api-inference.modelscope.cn/v1"
-OPENAI_MODEL="Qwen/Qwen3-Coder-480B-A35B-Instruct"
-EOF
-```
-
-**User-wide settings** (available in every directory):
-
-```bash
-mkdir -p ~/.qwen
-cat >> ~/.qwen/.env <<'EOF'
-OPENAI_API_KEY="your-api-key"
-OPENAI_BASE_URL="https://dashscope.aliyuncs.com/compatible-mode/v1"
-OPENAI_MODEL="qwen3-coder-plus"
-EOF
-```
-
-## Non-Interactive Mode / Headless Environments
-
-When running Qwen Code in a non-interactive environment, you cannot use the OAuth login flow.
-Instead, you must configure authentication using environment variables.
-
-The CLI will automatically detect if it is running in a non-interactive terminal and will use the
-OpenAI-compatible API method if configured:
-
-1.  **OpenAI-Compatible API:**
-    - Set the `OPENAI_API_KEY` environment variable.
-    - Optionally set `OPENAI_BASE_URL` and `OPENAI_MODEL` for custom endpoints.
-    - The CLI will use these credentials to authenticate with the API provider.
-
-**Example for headless environments:**
-
-```bash
-export OPENAI_API_KEY="your-api-key"
-export OPENAI_BASE_URL="https://api-inference.modelscope.cn/v1"
-export OPENAI_MODEL="Qwen/Qwen3-Coder-480B-A35B-Instruct"
-
-# Run Qwen Code
-qwen
-```
-
-If no API key is set in a non-interactive session, the CLI will exit with an error prompting you to configure authentication.

docs/cli/commands.md

@@ -1,357 +0,0 @@
-# CLI Commands
-
-Qwen Code supports several built-in commands to help you manage your session, customize the interface, and control its behavior. These commands are prefixed with a forward slash (`/`), an at symbol (`@`), or an exclamation mark (`!`).
-
-## Slash commands (`/`)
-
-Slash commands provide meta-level control over the CLI itself.
-
-### Built-in Commands
-
-- **`/bug`**
-  - **Description:** File an issue about Qwen Code. By default, the issue is filed within the GitHub repository for Qwen Code. The string you enter after `/bug` will become the headline for the bug being filed. The default `/bug` behavior can be modified using the `bugCommand` setting in your `.qwen/settings.json` files.
-
-- **`/chat`**
-  - **Description:** Save and resume conversation history for branching conversation state interactively, or resuming a previous state from a later session.
-  - **Sub-commands:**
-    - **`save`**
-      - **Description:** Saves the current conversation history. You must add a `<tag>` for identifying the conversation state.
-      - **Usage:** `/chat save <tag>`
-      - **Details on Checkpoint Location:** The default locations for saved chat checkpoints are:
-        - Linux/macOS: `~/.config/google-generative-ai/checkpoints/`
-        - Windows: `C:\Users\<YourUsername>\AppData\Roaming\google-generative-ai\checkpoints\`
-        - When you run `/chat list`, the CLI only scans these specific directories to find available checkpoints.
-        - **Note:** These checkpoints are for manually saving and resuming conversation states. For automatic checkpoints created before file modifications, see the [Checkpointing documentation](../checkpointing.md).
-    - **`resume`**
-      - **Description:** Resumes a conversation from a previous save.
-      - **Usage:** `/chat resume <tag>`
-    - **`list`**
-      - **Description:** Lists available tags for chat state resumption.
-
-- **`/clear`**
-  - **Description:** Clear the terminal screen, including the visible session history and scrollback within the CLI. The underlying session data (for history recall) might be preserved depending on the exact implementation, but the visual display is cleared.
-  - **Keyboard shortcut:** Press **Ctrl+L** at any time to perform a clear action.
-
-- **`/compress`**
-  - **Description:** Replace the entire chat context with a summary. This saves on tokens used for future tasks while retaining a high level summary of what has happened.
-
-- **`/copy`**
-  - **Description:** Copies the last output produced by Qwen Code to your clipboard, for easy sharing or reuse.
-
-- **`/directory`** (or **`/dir`**)
-  - **Description:** Manage workspace directories for multi-directory support.
-  - **Sub-commands:**
-    - **`add`**:
-      - **Description:** Add a directory to the workspace. The path can be absolute or relative to the current working directory. Moreover, the reference from home directory is supported as well.
-      - **Usage:** `/directory add <path1>,<path2>`
-      - **Note:** Disabled in restrictive sandbox profiles. If you're using that, use `--include-directories` when starting the session instead.
-    - **`show`**:
-      - **Description:** Display all directories added by `/direcotry add` and `--include-directories`.
-      - **Usage:** `/directory show`
-
-- **`/editor`**
-  - **Description:** Open a dialog for selecting supported editors.
-
-- **`/extensions`**
-  - **Description:** Lists all active extensions in the current Qwen Code session. See [Qwen Code Extensions](../extension.md).
-
-- **`/help`** (or **`/?`**)
-  - **Description:** Display help information about the Qwen Code, including available commands and their usage.
-
-- **`/mcp`**
-  - **Description:** List configured Model Context Protocol (MCP) servers, their connection status, server details, and available tools.
-  - **Sub-commands:**
-    - **`desc`** or **`descriptions`**:
-      - **Description:** Show detailed descriptions for MCP servers and tools.
-    - **`nodesc`** or **`nodescriptions`**:
-      - **Description:** Hide tool descriptions, showing only the tool names.
-    - **`schema`**:
-      - **Description:** Show the full JSON schema for the tool's configured parameters.
-  - **Keyboard Shortcut:** Press **Ctrl+T** at any time to toggle between showing and hiding tool descriptions.
-
-- **`/memory`**
-  - **Description:** Manage the AI's instructional context (hierarchical memory loaded from `GEMINI.md` files).
-  - **Sub-commands:**
-    - **`add`**:
-      - **Description:** Adds the following text to the AI's memory. Usage: `/memory add <text to remember>`
-    - **`show`**:
-      - **Description:** Display the full, concatenated content of the current hierarchical memory that has been loaded from all `GEMINI.md` files. This lets you inspect the instructional context being provided to the Gemini model.
-    - **`refresh`**:
-      - **Description:** Reload the hierarchical instructional memory from all `GEMINI.md` files found in the configured locations (global, project/ancestors, and sub-directories). This command updates the model with the latest `GEMINI.md` content.
-    - **Note:** For more details on how `GEMINI.md` files contribute to hierarchical memory, see the [CLI Configuration documentation](./configuration.md#4-geminimd-files-hierarchical-instructional-context).
-
-- **`/restore`**
-  - **Description:** Restores the project files to the state they were in just before a tool was executed. This is particularly useful for undoing file edits made by a tool. If run without a tool call ID, it will list available checkpoints to restore from.
-  - **Usage:** `/restore [tool_call_id]`
-  - **Note:** Only available if the CLI is invoked with the `--checkpointing` option or configured via [settings](./configuration.md). See [Checkpointing documentation](../checkpointing.md) for more details.
-
-- **`/stats`**
-  - **Description:** Display detailed statistics for the current Qwen Code session, including token usage, cached token savings (when available), and session duration. Note: Cached token information is only displayed when cached tokens are being used, which occurs with API key authentication but not with OAuth authentication at this time.
-
-- [**`/theme`**](./themes.md)
-  - **Description:** Open a dialog that lets you change the visual theme of Qwen Code.
-
-- **`/auth`**
-  - **Description:** Open a dialog that lets you change the authentication method.
-
-- **`/about`**
-  - **Description:** Show version info. Please share this information when filing issues.
-
-- [**`/tools`**](../tools/index.md)
-  - **Description:** Display a list of tools that are currently available within Qwen Code.
-  - **Sub-commands:**
-    - **`desc`** or **`descriptions`**:
-      - **Description:** Show detailed descriptions of each tool, including each tool's name with its full description as provided to the model.
-    - **`nodesc`** or **`nodescriptions`**:
-      - **Description:** Hide tool descriptions, showing only the tool names.
-
-- **`/privacy`**
-  - **Description:** Display the Privacy Notice and allow users to select whether they consent to the collection of their data for service improvement purposes.
-
-- **`/quit`** (or **`/exit`**)
-  - **Description:** Exit Qwen Code.
-
-- **`/vim`**
-  - **Description:** Toggle vim mode on or off. When vim mode is enabled, the input area supports vim-style navigation and editing commands in both NORMAL and INSERT modes.
-  - **Features:**
-    - **NORMAL mode:** Navigate with `h`, `j`, `k`, `l`; jump by words with `w`, `b`, `e`; go to line start/end with `0`, `$`, `^`; go to specific lines with `G` (or `gg` for first line)
-    - **INSERT mode:** Standard text input with escape to return to NORMAL mode
-    - **Editing commands:** Delete with `x`, change with `c`, insert with `i`, `a`, `o`, `O`; complex operations like `dd`, `cc`, `dw`, `cw`
-    - **Count support:** Prefix commands with numbers (e.g., `3h`, `5w`, `10G`)
-    - **Repeat last command:** Use `.` to repeat the last editing operation
-    - **Persistent setting:** Vim mode preference is saved to `~/.gemini/settings.json` and restored between sessions
-  - **Status indicator:** When enabled, shows `[NORMAL]` or `[INSERT]` in the footer
-
-- **`/init`**
-  - **Description:** To help users easily create a `GEMINI.md` file, this command analyzes the current directory and generates a tailored context file, making it simpler for them to provide project-specific instructions to the Gemini agent.
-
-### Custom Commands
-
-For a quick start, see the [example](#example-a-pure-function-refactoring-command) below.
-
-Custom commands allow you to save and reuse your favorite or most frequently used prompts as personal shortcuts within Gemini CLI. You can create commands that are specific to a single project or commands that are available globally across all your projects, streamlining your workflow and ensuring consistency.
-
-#### File Locations & Precedence
-
-Gemini CLI discovers commands from two locations, loaded in a specific order:
-
-1.  **User Commands (Global):** Located in `~/.gemini/commands/`. These commands are available in any project you are working on.
-2.  **Project Commands (Local):** Located in `<your-project-root>/.gemini/commands/`. These commands are specific to the current project and can be checked into version control to be shared with your team.
-
-If a command in the project directory has the same name as a command in the user directory, the **project command will always be used.** This allows projects to override global commands with project-specific versions.
-
-#### Naming and Namespacing
-
-The name of a command is determined by its file path relative to its `commands` directory. Subdirectories are used to create namespaced commands, with the path separator (`/` or `\`) being converted to a colon (`:`).
-
-- A file at `~/.gemini/commands/test.toml` becomes the command `/test`.
-- A file at `<project>/.gemini/commands/git/commit.toml` becomes the namespaced command `/git:commit`.
-
-#### TOML File Format (v1)
-
-Your command definition files must be written in the TOML format and use the `.toml` file extension.
-
-##### Required Fields
-
-- `prompt` (String): The prompt that will be sent to the Gemini model when the command is executed. This can be a single-line or multi-line string.
-
-##### Optional Fields
-
-- `description` (String): A brief, one-line description of what the command does. This text will be displayed next to your command in the `/help` menu. **If you omit this field, a generic description will be generated from the filename.**
-
-#### Handling Arguments
-
-Custom commands support two powerful, low-friction methods for handling arguments. The CLI automatically chooses the correct method based on the content of your command's `prompt`.
-
-##### 1. Shorthand Injection with `{{args}}`
-
-If your `prompt` contains the special placeholder `{{args}}`, the CLI will replace that exact placeholder with all the text the user typed after the command name. This is perfect for simple, deterministic commands where you need to inject user input into a specific place in a larger prompt template.
-
-**Example (`git/fix.toml`):**
-
-```toml
-# In: ~/.gemini/commands/git/fix.toml
-# Invoked via: /git:fix "Button is misaligned on mobile"
-
-description = "Generates a fix for a given GitHub issue."
-prompt = "Please analyze the staged git changes and provide a code fix for the issue described here: {{args}}."
-```
-
-The model will receive the final prompt: `Please analyze the staged git changes and provide a code fix for the issue described here: "Button is misaligned on mobile".`
-
-##### 2. Default Argument Handling
-
-If your `prompt` does **not** contain the special placeholder `{{args}}`, the CLI uses a default behavior for handling arguments.
-
-If you provide arguments to the command (e.g., `/mycommand arg1`), the CLI will append the full command you typed to the end of the prompt, separated by two newlines. This allows the model to see both the original instructions and the specific arguments you just provided.
-
-If you do **not** provide any arguments (e.g., `/mycommand`), the prompt is sent to the model exactly as it is, with nothing appended.
-
-**Example (`changelog.toml`):**
-
-This example shows how to create a robust command by defining a role for the model, explaining where to find the user's input, and specifying the expected format and behavior.
-
-```toml
-# In: <project>/.gemini/commands/changelog.toml
-# Invoked via: /changelog 1.2.0 added "Support for default argument parsing."
-
-description = "Adds a new entry to the project's CHANGELOG.md file."
-prompt = """
-# Task: Update Changelog
-
-You are an expert maintainer of this software project. A user has invoked a command to add a new entry to the changelog.
-
-**The user's raw command is appended below your instructions.**
-
-Your task is to parse the `<version>`, `<change_type>`, and `<message>` from their input and use the `write_file` tool to correctly update the `CHANGELOG.md` file.
-
-## Expected Format
-The command follows this format: `/changelog <version> <type> <message>`
-- `<type>` must be one of: "added", "changed", "fixed", "removed".
-
-## Behavior
-1. Read the `CHANGELOG.md` file.
-2. Find the section for the specified `<version>`.
-3. Add the `<message>` under the correct `<type>` heading.
-4. If the version or type section doesn't exist, create it.
-5. Adhere strictly to the "Keep a Changelog" format.
-"""
-```
-
-When you run `/changelog 1.2.0 added "New feature"`, the final text sent to the model will be the original prompt followed by two newlines and the command you typed.
-
-##### 3. Executing Shell Commands with `!{...}`
-
-You can make your commands dynamic by executing shell commands directly within your `prompt` and injecting their output. This is ideal for gathering context from your local environment, like reading file content or checking the status of Git.
-
-When a custom command attempts to execute a shell command, Gemini CLI will now prompt you for confirmation before proceeding. This is a security measure to ensure that only intended commands can be run.
-
-**How It Works:**
-
-1.  **Inject Commands:** Use the `!{...}` syntax in your `prompt` to specify where the command should be run and its output injected.
-2.  **Confirm Execution:** When you run the command, a dialog will appear listing the shell commands the prompt wants to execute.
-3.  **Grant Permission:** You can choose to:
-    - **Allow once:** The command(s) will run this one time.
-    - **Allow always for this session:** The command(s) will be added to a temporary allowlist for the current CLI session and will not require confirmation again.
-    - **No:** Cancel the execution of the shell command(s).
-
-The CLI still respects the global `excludeTools` and `coreTools` settings. A command will be blocked without a confirmation prompt if it is explicitly disallowed in your configuration.
-
-**Example (`git/commit.toml`):**
-
-This command gets the staged git diff and uses it to ask the model to write a commit message.
-
-````toml
-# In: <project>/.gemini/commands/git/commit.toml
-# Invoked via: /git:commit
-
-description = "Generates a Git commit message based on staged changes."
-
-# The prompt uses !{...} to execute the command and inject its output.
-prompt = """
-Please generate a Conventional Commit message based on the following git diff:
-
-```diff
-!{git diff --staged}
-````
-
-"""
-
-````
-
-When you run `/git:commit`, the CLI first executes `git diff --staged`, then replaces `!{git diff --staged}` with the output of that command before sending the final, complete prompt to the model.
-
----
-
-#### Example: A "Pure Function" Refactoring Command
-
-Let's create a global command that asks the model to refactor a piece of code.
-
-**1. Create the file and directories:**
-
-First, ensure the user commands directory exists, then create a `refactor` subdirectory for organization and the final TOML file.
-
-```bash
-mkdir -p ~/.gemini/commands/refactor
-touch ~/.gemini/commands/refactor/pure.toml
-````
-
-**2. Add the content to the file:**
-
-Open `~/.gemini/commands/refactor/pure.toml` in your editor and add the following content. We are including the optional `description` for best practice.
-
-```toml
-# In: ~/.gemini/commands/refactor/pure.toml
-# This command will be invoked via: /refactor:pure
-
-description = "Asks the model to refactor the current context into a pure function."
-
-prompt = """
-Please analyze the code I've provided in the current context.
-Refactor it into a pure function.
-
-Your response should include:
-1. The refactored, pure function code block.
-2. A brief explanation of the key changes you made and why they contribute to purity.
-"""
-```
-
-**3. Run the Command:**
-
-That's it! You can now run your command in the CLI. First, you might add a file to the context, and then invoke your command:
-
-```
-> @my-messy-function.js
-> /refactor:pure
-```
-
-Gemini CLI will then execute the multi-line prompt defined in your TOML file.
-
-## At commands (`@`)
-
-At commands are used to include the content of files or directories as part of your prompt to Gemini. These commands include git-aware filtering.
-
-- **`@<path_to_file_or_directory>`**
-  - **Description:** Inject the content of the specified file or files into your current prompt. This is useful for asking questions about specific code, text, or collections of files.
-  - **Examples:**
-    - `@path/to/your/file.txt Explain this text.`
-    - `@src/my_project/ Summarize the code in this directory.`
-    - `What is this file about? @README.md`
-  - **Details:**
-    - If a path to a single file is provided, the content of that file is read.
-    - If a path to a directory is provided, the command attempts to read the content of files within that directory and any subdirectories.
-    - Spaces in paths should be escaped with a backslash (e.g., `@My\ Documents/file.txt`).
-    - The command uses the `read_many_files` tool internally. The content is fetched and then inserted into your query before being sent to the Gemini model.
-    - **Git-aware filtering:** By default, git-ignored files (like `node_modules/`, `dist/`, `.env`, `.git/`) are excluded. This behavior can be changed via the `fileFiltering` settings.
-    - **File types:** The command is intended for text-based files. While it might attempt to read any file, binary files or very large files might be skipped or truncated by the underlying `read_many_files` tool to ensure performance and relevance. The tool indicates if files were skipped.
-  - **Output:** The CLI will show a tool call message indicating that `read_many_files` was used, along with a message detailing the status and the path(s) that were processed.
-
-- **`@` (Lone at symbol)**
-  - **Description:** If you type a lone `@` symbol without a path, the query is passed as-is to the Gemini model. This might be useful if you are specifically talking _about_ the `@` symbol in your prompt.
-
-### Error handling for `@` commands
-
-- If the path specified after `@` is not found or is invalid, an error message will be displayed, and the query might not be sent to the Gemini model, or it will be sent without the file content.
-- If the `read_many_files` tool encounters an error (e.g., permission issues), this will also be reported.
-
-## Shell mode & passthrough commands (`!`)
-
-The `!` prefix lets you interact with your system's shell directly from within Gemini CLI.
-
-- **`!<shell_command>`**
-  - **Description:** Execute the given `<shell_command>` using `bash` on Linux/macOS or `cmd.exe` on Windows. Any output or errors from the command are displayed in the terminal.
-  - **Examples:**
-    - `!ls -la` (executes `ls -la` and returns to Gemini CLI)
-    - `!git status` (executes `git status` and returns to Gemini CLI)
-
-- **`!` (Toggle shell mode)**
-  - **Description:** Typing `!` on its own toggles shell mode.
-    - **Entering shell mode:**
-      - When active, shell mode uses a different coloring and a "Shell Mode Indicator".
-      - While in shell mode, text you type is interpreted directly as a shell command.
-    - **Exiting shell mode:**
-      - When exited, the UI reverts to its standard appearance and normal Gemini CLI behavior resumes.
-
-- **Caution for all `!` usage:** Commands you execute in shell mode have the same permissions and impact as if you ran them directly in your terminal.
-
-- **Environment Variable:** When a command is executed via `!` or in shell mode, the `GEMINI_CLI=1` environment variable is set in the subprocess's environment. This allows scripts or tools to detect if they are being run from within the Gemini CLI.

docs/cli/configuration.md

@@ -1,525 +0,0 @@
-# Gemini CLI Configuration
-
-Gemini CLI offers several ways to configure its behavior, including environment variables, command-line arguments, and settings files. This document outlines the different configuration methods and available settings.
-
-## Configuration layers
-
-Configuration is applied in the following order of precedence (lower numbers are overridden by higher numbers):
-
-1.  **Default values:** Hardcoded defaults within the application.
-2.  **User settings file:** Global settings for the current user.
-3.  **Project settings file:** Project-specific settings.
-4.  **System settings file:** System-wide settings.
-5.  **Environment variables:** System-wide or session-specific variables, potentially loaded from `.env` files.
-6.  **Command-line arguments:** Values passed when launching the CLI.
-
-## Settings files
-
-Gemini CLI uses `settings.json` files for persistent configuration. There are three locations for these files:
-
-- **User settings file:**
-  - **Location:** `~/.qwen/settings.json` (where `~` is your home directory).
-  - **Scope:** Applies to all Gemini CLI sessions for the current user.
-- **Project settings file:**
-  - **Location:** `.qwen/settings.json` within your project's root directory.
-  - **Scope:** Applies only when running Gemini CLI from that specific project. Project settings override user settings.
-- **System settings file:**
-  - **Location:** `/etc/gemini-cli/settings.json` (Linux), `C:\ProgramData\gemini-cli\settings.json` (Windows) or `/Library/Application Support/GeminiCli/settings.json` (macOS). The path can be overridden using the `GEMINI_CLI_SYSTEM_SETTINGS_PATH` environment variable.
-  - **Scope:** Applies to all Gemini CLI sessions on the system, for all users. System settings override user and project settings. May be useful for system administrators at enterprises to have controls over users' Gemini CLI setups.
-
-**Note on environment variables in settings:** String values within your `settings.json` files can reference environment variables using either `$VAR_NAME` or `${VAR_NAME}` syntax. These variables will be automatically resolved when the settings are loaded. For example, if you have an environment variable `MY_API_TOKEN`, you could use it in `settings.json` like this: `"apiKey": "$MY_API_TOKEN"`.
-
-### The `.gemini` directory in your project
-
-In addition to a project settings file, a project's `.gemini` directory can contain other project-specific files related to Gemini CLI's operation, such as:
-
-- [Custom sandbox profiles](#sandboxing) (e.g., `.qwen/sandbox-macos-custom.sb`, `.qwen/sandbox.Dockerfile`).
-
-### Available settings in `settings.json`:
-
-- **`contextFileName`** (string or array of strings):
-  - **Description:** Specifies the filename for context files (e.g., `GEMINI.md`, `AGENTS.md`). Can be a single filename or a list of accepted filenames.
-  - **Default:** `GEMINI.md`
-  - **Example:** `"contextFileName": "AGENTS.md"`
-
-- **`bugCommand`** (object):
-  - **Description:** Overrides the default URL for the `/bug` command.
-  - **Default:** `"urlTemplate": "https://github.com/google-gemini/gemini-cli/issues/new?template=bug_report.yml&title={title}&info={info}"`
-  - **Properties:**
-    - **`urlTemplate`** (string): A URL that can contain `{title}` and `{info}` placeholders.
-  - **Example:**
-    ```json
-    "bugCommand": {
-      "urlTemplate": "https://bug.example.com/new?title={title}&info={info}"
-    }
-    ```
-
-- **`fileFiltering`** (object):
-  - **Description:** Controls git-aware file filtering behavior for @ commands and file discovery tools.
-  - **Default:** `"respectGitIgnore": true, "enableRecursiveFileSearch": true`
-  - **Properties:**
-    - **`respectGitIgnore`** (boolean): Whether to respect .gitignore patterns when discovering files. When set to `true`, git-ignored files (like `node_modules/`, `dist/`, `.env`) are automatically excluded from @ commands and file listing operations.
-    - **`enableRecursiveFileSearch`** (boolean): Whether to enable searching recursively for filenames under the current tree when completing @ prefixes in the prompt.
-  - **Example:**
-    ```json
-    "fileFiltering": {
-      "respectGitIgnore": true,
-      "enableRecursiveFileSearch": false
-    }
-    ```
-
-- **`coreTools`** (array of strings):
-  - **Description:** Allows you to specify a list of core tool names that should be made available to the model. This can be used to restrict the set of built-in tools. See [Built-in Tools](../core/tools-api.md#built-in-tools) for a list of core tools. You can also specify command-specific restrictions for tools that support it, like the `ShellTool`. For example, `"coreTools": ["ShellTool(ls -l)"]` will only allow the `ls -l` command to be executed.
-  - **Default:** All tools available for use by the Gemini model.
-  - **Example:** `"coreTools": ["ReadFileTool", "GlobTool", "ShellTool(ls)"]`.
-
-- **`excludeTools`** (array of strings):
-  - **Description:** Allows you to specify a list of core tool names that should be excluded from the model. A tool listed in both `excludeTools` and `coreTools` is excluded. You can also specify command-specific restrictions for tools that support it, like the `ShellTool`. For example, `"excludeTools": ["ShellTool(rm -rf)"]` will block the `rm -rf` command.
-  - **Default**: No tools excluded.
-  - **Example:** `"excludeTools": ["run_shell_command", "findFiles"]`.
-  - **Security Note:** Command-specific restrictions in
-    `excludeTools` for `run_shell_command` are based on simple string matching and can be easily bypassed. This feature is **not a security mechanism** and should not be relied upon to safely execute untrusted code. It is recommended to use `coreTools` to explicitly select commands
-    that can be executed.
-
-- **`allowMCPServers`** (array of strings):
-  - **Description:** Allows you to specify a list of MCP server names that should be made available to the model. This can be used to restrict the set of MCP servers to connect to. Note that this will be ignored if `--allowed-mcp-server-names` is set.
-  - **Default:** All MCP servers are available for use by the Gemini model.
-  - **Example:** `"allowMCPServers": ["myPythonServer"]`.
-  - **Security Note:** This uses simple string matching on MCP server names, which can be modified. If you're a system administrator looking to prevent users from bypassing this, consider configuring the `mcpServers` at the system settings level such that the user will not be able to configure any MCP servers of their own. This should not be used as an airtight security mechanism.
-
-- **`excludeMCPServers`** (array of strings):
-  - **Description:** Allows you to specify a list of MCP server names that should be excluded from the model. A server listed in both `excludeMCPServers` and `allowMCPServers` is excluded. Note that this will be ignored if `--allowed-mcp-server-names` is set.
-  - **Default**: No MCP servers excluded.
-  - **Example:** `"excludeMCPServers": ["myNodeServer"]`.
-  - **Security Note:** This uses simple string matching on MCP server names, which can be modified. If you're a system administrator looking to prevent users from bypassing this, consider configuring the `mcpServers` at the system settings level such that the user will not be able to configure any MCP servers of their own. This should not be used as an airtight security mechanism.
-
-- **`autoAccept`** (boolean):
-  - **Description:** Controls whether the CLI automatically accepts and executes tool calls that are considered safe (e.g., read-only operations) without explicit user confirmation. If set to `true`, the CLI will bypass the confirmation prompt for tools deemed safe.
-  - **Default:** `false`
-  - **Example:** `"autoAccept": true`
-
-- **`theme`** (string):
-  - **Description:** Sets the visual [theme](./themes.md) for Gemini CLI.
-  - **Default:** `"Default"`
-  - **Example:** `"theme": "GitHub"`
-
-- **`vimMode`** (boolean):
-  - **Description:** Enables or disables vim mode for input editing. When enabled, the input area supports vim-style navigation and editing commands with NORMAL and INSERT modes. The vim mode status is displayed in the footer and persists between sessions.
-  - **Default:** `false`
-  - **Example:** `"vimMode": true`
-
-- **`sandbox`** (boolean or string):
-  - **Description:** Controls whether and how to use sandboxing for tool execution. If set to `true`, Gemini CLI uses a pre-built `gemini-cli-sandbox` Docker image. For more information, see [Sandboxing](#sandboxing).
-  - **Default:** `false`
-  - **Example:** `"sandbox": "docker"`
-
-- **`toolDiscoveryCommand`** (string):
-  - **Description:** Defines a custom shell command for discovering tools from your project. The shell command must return on `stdout` a JSON array of [function declarations](https://ai.google.dev/gemini-api/docs/function-calling#function-declarations). Tool wrappers are optional.
-  - **Default:** Empty
-  - **Example:** `"toolDiscoveryCommand": "bin/get_tools"`
-
-- **`toolCallCommand`** (string):
-  - **Description:** Defines a custom shell command for calling a specific tool that was discovered using `toolDiscoveryCommand`. The shell command must meet the following criteria:
-    - It must take function `name` (exactly as in [function declaration](https://ai.google.dev/gemini-api/docs/function-calling#function-declarations)) as first command line argument.
-    - It must read function arguments as JSON on `stdin`, analogous to [`functionCall.args`](https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/inference#functioncall).
-    - It must return function output as JSON on `stdout`, analogous to [`functionResponse.response.content`](https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/inference#functionresponse).
-  - **Default:** Empty
-  - **Example:** `"toolCallCommand": "bin/call_tool"`
-
-- **`mcpServers`** (object):
-  - **Description:** Configures connections to one or more Model-Context Protocol (MCP) servers for discovering and using custom tools. Gemini CLI attempts to connect to each configured MCP server to discover available tools. If multiple MCP servers expose a tool with the same name, the tool names will be prefixed with the server alias you defined in the configuration (e.g., `serverAlias__actualToolName`) to avoid conflicts. Note that the system might strip certain schema properties from MCP tool definitions for compatibility.
-  - **Default:** Empty
-  - **Properties:**
-    - **`<SERVER_NAME>`** (object): The server parameters for the named server.
-      - `command` (string, required): The command to execute to start the MCP server.
-      - `args` (array of strings, optional): Arguments to pass to the command.
-      - `env` (object, optional): Environment variables to set for the server process.
-      - `cwd` (string, optional): The working directory in which to start the server.
-      - `timeout` (number, optional): Timeout in milliseconds for requests to this MCP server.
-      - `trust` (boolean, optional): Trust this server and bypass all tool call confirmations.
-      - `includeTools` (array of strings, optional): List of tool names to include from this MCP server. When specified, only the tools listed here will be available from this server (whitelist behavior). If not specified, all tools from the server are enabled by default.
-      - `excludeTools` (array of strings, optional): List of tool names to exclude from this MCP server. Tools listed here will not be available to the model, even if they are exposed by the server. **Note:** `excludeTools` takes precedence over `includeTools` - if a tool is in both lists, it will be excluded.
-  - **Example:**
-    ```json
-    "mcpServers": {
-      "myPythonServer": {
-        "command": "python",
-        "args": ["mcp_server.py", "--port", "8080"],
-        "cwd": "./mcp_tools/python",
-        "timeout": 5000,
-        "includeTools": ["safe_tool", "file_reader"],
-      },
-      "myNodeServer": {
-        "command": "node",
-        "args": ["mcp_server.js"],
-        "cwd": "./mcp_tools/node",
-        "excludeTools": ["dangerous_tool", "file_deleter"]
-      },
-      "myDockerServer": {
-        "command": "docker",
-        "args": ["run", "-i", "--rm", "-e", "API_KEY", "ghcr.io/foo/bar"],
-        "env": {
-          "API_KEY": "$MY_API_TOKEN"
-        }
-      }
-    }
-    ```
-
-- **`checkpointing`** (object):
-  - **Description:** Configures the checkpointing feature, which allows you to save and restore conversation and file states. See the [Checkpointing documentation](../checkpointing.md) for more details.
-  - **Default:** `{"enabled": false}`
-  - **Properties:**
-    - **`enabled`** (boolean): When `true`, the `/restore` command is available.
-
-- **`preferredEditor`** (string):
-  - **Description:** Specifies the preferred editor to use for viewing diffs.
-  - **Default:** `vscode`
-  - **Example:** `"preferredEditor": "vscode"`
-
-- **`telemetry`** (object)
-  - **Description:** Configures logging and metrics collection for Gemini CLI. For more information, see [Telemetry](../telemetry.md).
-  - **Default:** `{"enabled": false, "target": "local", "otlpEndpoint": "http://localhost:4317", "logPrompts": true}`
-  - **Properties:**
-    - **`enabled`** (boolean): Whether or not telemetry is enabled.
-    - **`target`** (string): The destination for collected telemetry. Supported values are `local` and `gcp`.
-    - **`otlpEndpoint`** (string): The endpoint for the OTLP Exporter.
-    - **`logPrompts`** (boolean): Whether or not to include the content of user prompts in the logs.
-  - **Example:**
-    ```json
-    "telemetry": {
-      "enabled": true,
-      "target": "local",
-      "otlpEndpoint": "http://localhost:16686",
-      "logPrompts": false
-    }
-    ```
-- **`usageStatisticsEnabled`** (boolean):
-  - **Description:** Enables or disables the collection of usage statistics. See [Usage Statistics](#usage-statistics) for more information.
-  - **Default:** `true`
-  - **Example:**
-    ```json
-    "usageStatisticsEnabled": false
-    ```
-
-- **`hideTips`** (boolean):
-  - **Description:** Enables or disables helpful tips in the CLI interface.
-  - **Default:** `false`
-  - **Example:**
-
-    ```json
-    "hideTips": true
-    ```
-
-- **`hideBanner`** (boolean):
-  - **Description:** Enables or disables the startup banner (ASCII art logo) in the CLI interface.
-  - **Default:** `false`
-  - **Example:**
-
-    ```json
-    "hideBanner": true
-    ```
-
-- **`maxSessionTurns`** (number):
-  - **Description:** Sets the maximum number of turns for a session. If the session exceeds this limit, the CLI will stop processing and start a new chat.
-  - **Default:** `-1` (unlimited)
-  - **Example:**
-    ```json
-    "maxSessionTurns": 10
-    ```
-
-- **`summarizeToolOutput`** (object):
-  - **Description:** Enables or disables the summarization of tool output. You can specify the token budget for the summarization using the `tokenBudget` setting.
-  - Note: Currently only the `run_shell_command` tool is supported.
-  - **Default:** `{}` (Disabled by default)
-  - **Example:**
-    ```json
-    "summarizeToolOutput": {
-      "run_shell_command": {
-        "tokenBudget": 2000
-      }
-    }
-    ```
-
-- **`excludedProjectEnvVars`** (array of strings):
-  - **Description:** Specifies environment variables that should be excluded from being loaded from project `.env` files. This prevents project-specific environment variables (like `DEBUG=true`) from interfering with gemini-cli behavior. Variables from `.gemini/.env` files are never excluded.
-  - **Default:** `["DEBUG", "DEBUG_MODE"]`
-  - **Example:**
-    ```json
-    "excludedProjectEnvVars": ["DEBUG", "DEBUG_MODE", "NODE_ENV"]
-    ```
-
-### Example `settings.json`:
-
-```json
-{
-  "theme": "GitHub",
-  "sandbox": "docker",
-  "toolDiscoveryCommand": "bin/get_tools",
-  "toolCallCommand": "bin/call_tool",
-  "mcpServers": {
-    "mainServer": {
-      "command": "bin/mcp_server.py"
-    },
-    "anotherServer": {
-      "command": "node",
-      "args": ["mcp_server.js", "--verbose"]
-    }
-  },
-  "telemetry": {
-    "enabled": true,
-    "target": "local",
-    "otlpEndpoint": "http://localhost:4317",
-    "logPrompts": true
-  },
-  "usageStatisticsEnabled": true,
-  "hideTips": false,
-  "hideBanner": false,
-  "maxSessionTurns": 10,
-  "summarizeToolOutput": {
-    "run_shell_command": {
-      "tokenBudget": 100
-    }
-  },
-  "excludedProjectEnvVars": ["DEBUG", "DEBUG_MODE", "NODE_ENV"]
-}
-```
-
-## Shell History
-
-The CLI keeps a history of shell commands you run. To avoid conflicts between different projects, this history is stored in a project-specific directory within your user's home folder.
-
-- **Location:** `~/.qwen/tmp/<project_hash>/shell_history`
-  - `<project_hash>` is a unique identifier generated from your project's root path.
-  - The history is stored in a file named `shell_history`.
-
-## Environment Variables & `.env` Files
-
-Environment variables are a common way to configure applications, especially for sensitive information like API keys or for settings that might change between environments.
-
-The CLI automatically loads environment variables from an `.env` file. The loading order is:
-
-1.  `.env` file in the current working directory.
-2.  If not found, it searches upwards in parent directories until it finds an `.env` file or reaches the project root (identified by a `.git` folder) or the home directory.
-3.  If still not found, it looks for `~/.env` (in the user's home directory).
-
-**Environment Variable Exclusion:** Some environment variables (like `DEBUG` and `DEBUG_MODE`) are automatically excluded from being loaded from project `.env` files to prevent interference with gemini-cli behavior. Variables from `.gemini/.env` files are never excluded. You can customize this behavior using the `excludedProjectEnvVars` setting in your `settings.json` file.
-
-- **`GEMINI_API_KEY`** (Required):
-  - Your API key for the Gemini API.
-  - **Crucial for operation.** The CLI will not function without it.
-  - Set this in your shell profile (e.g., `~/.bashrc`, `~/.zshrc`) or an `.env` file.
-- **`GEMINI_MODEL`**:
-  - Specifies the default Gemini model to use.
-  - Overrides the hardcoded default
-  - Example: `export GEMINI_MODEL="gemini-2.5-flash"`
-- **`GOOGLE_API_KEY`**:
-  - Your Google Cloud API key.
-  - Required for using Vertex AI in express mode.
-  - Ensure you have the necessary permissions.
-  - Example: `export GOOGLE_API_KEY="YOUR_GOOGLE_API_KEY"`.
-- **`GOOGLE_CLOUD_PROJECT`**:
-  - Your Google Cloud Project ID.
-  - Required for using Code Assist or Vertex AI.
-  - If using Vertex AI, ensure you have the necessary permissions in this project.
-  - **Cloud Shell Note:** When running in a Cloud Shell environment, this variable defaults to a special project allocated for Cloud Shell users. If you have `GOOGLE_CLOUD_PROJECT` set in your global environment in Cloud Shell, it will be overridden by this default. To use a different project in Cloud Shell, you must define `GOOGLE_CLOUD_PROJECT` in a `.env` file.
-  - Example: `export GOOGLE_CLOUD_PROJECT="YOUR_PROJECT_ID"`.
-- **`GOOGLE_APPLICATION_CREDENTIALS`** (string):
-  - **Description:** The path to your Google Application Credentials JSON file.
-  - **Example:** `export GOOGLE_APPLICATION_CREDENTIALS="/path/to/your/credentials.json"`
-- **`OTLP_GOOGLE_CLOUD_PROJECT`**:
-  - Your Google Cloud Project ID for Telemetry in Google Cloud
-  - Example: `export OTLP_GOOGLE_CLOUD_PROJECT="YOUR_PROJECT_ID"`.
-- **`GOOGLE_CLOUD_LOCATION`**:
-  - Your Google Cloud Project Location (e.g., us-central1).
-  - Required for using Vertex AI in non express mode.
-  - Example: `export GOOGLE_CLOUD_LOCATION="YOUR_PROJECT_LOCATION"`.
-- **`GEMINI_SANDBOX`**:
-  - Alternative to the `sandbox` setting in `settings.json`.
-  - Accepts `true`, `false`, `docker`, `podman`, or a custom command string.
-- **`SEATBELT_PROFILE`** (macOS specific):
-  - Switches the Seatbelt (`sandbox-exec`) profile on macOS.
-  - `permissive-open`: (Default) Restricts writes to the project folder (and a few other folders, see `packages/cli/src/utils/sandbox-macos-permissive-open.sb`) but allows other operations.
-  - `strict`: Uses a strict profile that declines operations by default.
-  - `<profile_name>`: Uses a custom profile. To define a custom profile, create a file named `sandbox-macos-<profile_name>.sb` in your project's `.qwen/` directory (e.g., `my-project/.qwen/sandbox-macos-custom.sb`).
-- **`DEBUG` or `DEBUG_MODE`** (often used by underlying libraries or the CLI itself):
-  - Set to `true` or `1` to enable verbose debug logging, which can be helpful for troubleshooting.
-  - **Note:** These variables are automatically excluded from project `.env` files by default to prevent interference with gemini-cli behavior. Use `.gemini/.env` files if you need to set these for gemini-cli specifically.
-- **`NO_COLOR`**:
-  - Set to any value to disable all color output in the CLI.
-- **`CLI_TITLE`**:
-  - Set to a string to customize the title of the CLI.
-- **`CODE_ASSIST_ENDPOINT`**:
-  - Specifies the endpoint for the code assist server.
-  - This is useful for development and testing.
-
-## Command-Line Arguments
-
-Arguments passed directly when running the CLI can override other configurations for that specific session.
-
-- **`--model <model_name>`** (**`-m <model_name>`**):
-  - Specifies the Gemini model to use for this session.
-  - Example: `npm start -- --model gemini-1.5-pro-latest`
-- **`--prompt <your_prompt>`** (**`-p <your_prompt>`**):
-  - Used to pass a prompt directly to the command. This invokes Gemini CLI in a non-interactive mode.
-- **`--prompt-interactive <your_prompt>`** (**`-i <your_prompt>`**):
-  - Starts an interactive session with the provided prompt as the initial input.
-  - The prompt is processed within the interactive session, not before it.
-  - Cannot be used when piping input from stdin.
-  - Example: `gemini -i "explain this code"`
-- **`--sandbox`** (**`-s`**):
-  - Enables sandbox mode for this session.
-- **`--sandbox-image`**:
-  - Sets the sandbox image URI.
-- **`--debug`** (**`-d`**):
-  - Enables debug mode for this session, providing more verbose output.
-- **`--all-files`** (**`-a`**):
-  - If set, recursively includes all files within the current directory as context for the prompt.
-- **`--help`** (or **`-h`**):
-  - Displays help information about command-line arguments.
-- **`--show-memory-usage`**:
-  - Displays the current memory usage.
-- **`--yolo`**:
-  - Enables YOLO mode, which automatically approves all tool calls.
-- **`--telemetry`**:
-  - Enables [telemetry](../telemetry.md).
-- **`--telemetry-target`**:
-  - Sets the telemetry target. See [telemetry](../telemetry.md) for more information.
-- **`--telemetry-otlp-endpoint`**:
-  - Sets the OTLP endpoint for telemetry. See [telemetry](../telemetry.md) for more information.
-- **`--telemetry-log-prompts`**:
-  - Enables logging of prompts for telemetry. See [telemetry](../telemetry.md) for more information.
-- **`--checkpointing`**:
-  - Enables [checkpointing](../checkpointing.md).
-- **`--extensions <extension_name ...>`** (**`-e <extension_name ...>`**):
-  - Specifies a list of extensions to use for the session. If not provided, all available extensions are used.
-  - Use the special term `gemini -e none` to disable all extensions.
-  - Example: `gemini -e my-extension -e my-other-extension`
-- **`--list-extensions`** (**`-l`**):
-  - Lists all available extensions and exits.
-- **`--proxy`**:
-  - Sets the proxy for the CLI.
-  - Example: `--proxy http://localhost:7890`.
-- **`--include-directories <dir1,dir2,...>`**:
-  - Includes additional directories in the workspace for multi-directory support.
-  - Can be specified multiple times or as comma-separated values.
-  - 5 directories can be added at maximum.
-  - Example: `--include-directories /path/to/project1,/path/to/project2` or `--include-directories /path/to/project1 --include-directories /path/to/project2`
-- **`--version`**:
-  - Displays the version of the CLI.
-- **`--openai-logging`**:
-  - Enables logging of OpenAI API calls for debugging and analysis. This flag overrides the `enableOpenAILogging` setting in `settings.json`.
-
-## Context Files (Hierarchical Instructional Context)
-
-While not strictly configuration for the CLI's _behavior_, context files (defaulting to `GEMINI.md` but configurable via the `contextFileName` setting) are crucial for configuring the _instructional context_ (also referred to as "memory") provided to the Gemini model. This powerful feature allows you to give project-specific instructions, coding style guides, or any relevant background information to the AI, making its responses more tailored and accurate to your needs. The CLI includes UI elements, such as an indicator in the footer showing the number of loaded context files, to keep you informed about the active context.
-
-- **Purpose:** These Markdown files contain instructions, guidelines, or context that you want the Gemini model to be aware of during your interactions. The system is designed to manage this instructional context hierarchically.
-
-### Example Context File Content (e.g., `GEMINI.md`)
-
-Here's a conceptual example of what a context file at the root of a TypeScript project might contain:
-
-```markdown
-# Project: My Awesome TypeScript Library
-
-## General Instructions:
-
-- When generating new TypeScript code, please follow the existing coding style.
-- Ensure all new functions and classes have JSDoc comments.
-- Prefer functional programming paradigms where appropriate.
-- All code should be compatible with TypeScript 5.0 and Node.js 20+.
-
-## Coding Style:
-
-- Use 2 spaces for indentation.
-- Interface names should be prefixed with `I` (e.g., `IUserService`).
-- Private class members should be prefixed with an underscore (`_`).
-- Always use strict equality (`===` and `!==`).
-
-## Specific Component: `src/api/client.ts`
-
-- This file handles all outbound API requests.
-- When adding new API call functions, ensure they include robust error handling and logging.
-- Use the existing `fetchWithRetry` utility for all GET requests.
-
-## Regarding Dependencies:
-
-- Avoid introducing new external dependencies unless absolutely necessary.
-- If a new dependency is required, please state the reason.
-```
-
-This example demonstrates how you can provide general project context, specific coding conventions, and even notes about particular files or components. The more relevant and precise your context files are, the better the AI can assist you. Project-specific context files are highly encouraged to establish conventions and context.
-
-- **Hierarchical Loading and Precedence:** The CLI implements a sophisticated hierarchical memory system by loading context files (e.g., `GEMINI.md`) from several locations. Content from files lower in this list (more specific) typically overrides or supplements content from files higher up (more general). The exact concatenation order and final context can be inspected using the `/memory show` command. The typical loading order is:
-  1.  **Global Context File:**
-      - Location: `~/.gemini/<contextFileName>` (e.g., `~/.gemini/GEMINI.md` in your user home directory).
-      - Scope: Provides default instructions for all your projects.
-  2.  **Project Root & Ancestors Context Files:**
-      - Location: The CLI searches for the configured context file in the current working directory and then in each parent directory up to either the project root (identified by a `.git` folder) or your home directory.
-      - Scope: Provides context relevant to the entire project or a significant portion of it.
-  3.  **Sub-directory Context Files (Contextual/Local):**
-      - Location: The CLI also scans for the configured context file in subdirectories _below_ the current working directory (respecting common ignore patterns like `node_modules`, `.git`, etc.). The breadth of this search is limited to 200 directories by default, but can be configured with a `memoryDiscoveryMaxDirs` field in your `settings.json` file.
-      - Scope: Allows for highly specific instructions relevant to a particular component, module, or subsection of your project.
-- **Concatenation & UI Indication:** The contents of all found context files are concatenated (with separators indicating their origin and path) and provided as part of the system prompt to the Gemini model. The CLI footer displays the count of loaded context files, giving you a quick visual cue about the active instructional context.
-- **Importing Content:** You can modularize your context files by importing other Markdown files using the `@path/to/file.md` syntax. For more details, see the [Memory Import Processor documentation](../core/memport.md).
-- **Commands for Memory Management:**
-  - Use `/memory refresh` to force a re-scan and reload of all context files from all configured locations. This updates the AI's instructional context.
-  - Use `/memory show` to display the combined instructional context currently loaded, allowing you to verify the hierarchy and content being used by the AI.
-  - See the [Commands documentation](./commands.md#memory) for full details on the `/memory` command and its sub-commands (`show` and `refresh`).
-
-By understanding and utilizing these configuration layers and the hierarchical nature of context files, you can effectively manage the AI's memory and tailor the Gemini CLI's responses to your specific needs and projects.
-
-## Sandboxing
-
-The Gemini CLI can execute potentially unsafe operations (like shell commands and file modifications) within a sandboxed environment to protect your system.
-
-Sandboxing is disabled by default, but you can enable it in a few ways:
-
-- Using `--sandbox` or `-s` flag.
-- Setting `GEMINI_SANDBOX` environment variable.
-- Sandbox is enabled in `--yolo` mode by default.
-
-By default, it uses a pre-built `gemini-cli-sandbox` Docker image.
-
-For project-specific sandboxing needs, you can create a custom Dockerfile at `.gemini/sandbox.Dockerfile` in your project's root directory. This Dockerfile can be based on the base sandbox image:
-
-```dockerfile
-FROM gemini-cli-sandbox
-
-# Add your custom dependencies or configurations here
-# For example:
-# RUN apt-get update && apt-get install -y some-package
-# COPY ./my-config /app/my-config
-```
-
-When `.gemini/sandbox.Dockerfile` exists, you can use `BUILD_SANDBOX` environment variable when running Gemini CLI to automatically build the custom sandbox image:
-
-```bash
-BUILD_SANDBOX=1 gemini -s
-```
-
-## Usage Statistics
-
-To help us improve the Gemini CLI, we collect anonymized usage statistics. This data helps us understand how the CLI is used, identify common issues, and prioritize new features.
-
-**What we collect:**
-
-- **Tool Calls:** We log the names of the tools that are called, whether they succeed or fail, and how long they take to execute. We do not collect the arguments passed to the tools or any data returned by them.
-- **API Requests:** We log the Gemini model used for each request, the duration of the request, and whether it was successful. We do not collect the content of the prompts or responses.
-- **Session Information:** We collect information about the configuration of the CLI, such as the enabled tools and the approval mode.
-
-**What we DON'T collect:**
-
-- **Personally Identifiable Information (PII):** We do not collect any personal information, such as your name, email address, or API keys.
-- **Prompt and Response Content:** We do not log the content of your prompts or the responses from the Gemini model.
-- **File Content:** We do not log the content of any files that are read or written by the CLI.
-
-**How to opt out:**
-
-You can opt out of usage statistics collection at any time by setting the `usageStatisticsEnabled` property to `false` in your `settings.json` file:
-
-```json
-{
-  "usageStatisticsEnabled": false
-}
-```

docs/cli/index.md

@@ -1,28 +0,0 @@
-# Qwen Code CLI
-
-Within Qwen Code, `packages/cli` is the frontend for users to send and receive prompts with Qwen and other AI models and their associated tools. For a general overview of Qwen Code, see the [main documentation page](../index.md).
-
-## Navigating this section
-
-- **[Authentication](./authentication.md):** A guide to setting up authentication with Qwen OAuth and OpenAI-compatible providers.
-- **[Commands](./commands.md):** A reference for Qwen Code CLI commands (e.g., `/help`, `/tools`, `/theme`).
-- **[Configuration](./configuration.md):** A guide to tailoring Qwen Code CLI behavior using configuration files.
-- **[Token Caching](./token-caching.md):** Optimize API costs through token caching.
-- **[Themes](./themes.md)**: A guide to customizing the CLI's appearance with different themes.
-- **[Tutorials](tutorials.md)**: A tutorial showing how to use Qwen Code to automate a development task.
-
-## Non-interactive mode
-
-Qwen Code can be run in a non-interactive mode, which is useful for scripting and automation. In this mode, you pipe input to the CLI, it executes the command, and then it exits.
-
-The following example pipes a command to Qwen Code from your terminal:
-
-```bash
-echo "What is fine tuning?" | qwen
-```
-
-Qwen Code executes the command and prints the output to your terminal. Note that you can achieve the same behavior by using the `--prompt` or `-p` flag. For example:
-
-```bash
-qwen -p "What is fine tuning?"
-```

docs/cli/openai-auth.md

@@ -1,76 +0,0 @@
-# OpenAI Authentication
-
-Qwen Code CLI supports OpenAI authentication for users who want to use OpenAI models instead of Google's Gemini models.
-
-## Authentication Methods
-
-### 1. Interactive Authentication (Recommended)
-
-When you first run the CLI and select OpenAI as your authentication method, you'll be prompted to enter:
-
-- **API Key**: Your OpenAI API key from [https://platform.openai.com/api-keys](https://platform.openai.com/api-keys)
-- **Base URL**: The base URL for OpenAI API (defaults to `https://api.openai.com/v1`)
-- **Model**: The OpenAI model to use (defaults to `gpt-4o`)
-
-The CLI will guide you through each field:
-
-1. Enter your API key and press Enter
-2. Review/modify the base URL and press Enter
-3. Review/modify the model name and press Enter
-
-**Note**: You can paste your API key directly - the CLI supports paste functionality and will display the full key for verification.
-
-### 2. Command Line Arguments
-
-You can also provide the OpenAI credentials via command line arguments:
-
-```bash
-# Basic usage with API key
-qwen-code --openai-api-key "your-api-key-here"
-
-# With custom base URL
-qwen-code --openai-api-key "your-api-key-here" --openai-base-url "https://your-custom-endpoint.com/v1"
-
-# With custom model
-qwen-code --openai-api-key "your-api-key-here" --model "gpt-4-turbo"
-```
-
-### 3. Environment Variables
-
-Set the following environment variables in your shell or `.env` file:
-
-```bash
-export OPENAI_API_KEY="your-api-key-here"
-export OPENAI_BASE_URL="https://api.openai.com/v1"  # Optional, defaults to this value
-export OPENAI_MODEL="gpt-4o"  # Optional, defaults to gpt-4o
-```
-
-## Supported Models
-
-The CLI supports all OpenAI models that are available through the OpenAI API, including:
-
-- `gpt-4o` (default)
-- `gpt-4o-mini`
-- `gpt-4-turbo`
-- `gpt-4`
-- `gpt-3.5-turbo`
-- And other available models
-
-## Custom Endpoints
-
-You can use custom endpoints by setting the `OPENAI_BASE_URL` environment variable or using the `--openai-base-url` command line argument. This is useful for:
-
-- Using Azure OpenAI
-- Using other OpenAI-compatible APIs
-- Using local OpenAI-compatible servers
-
-## Switching Authentication Methods
-
-To switch between authentication methods, use the `/auth` command in the CLI interface.
-
-## Security Notes
-
-- API keys are stored in memory during the session
-- For persistent storage, use environment variables or `.env` files
-- Never commit API keys to version control
-- The CLI displays API keys in plain text for verification - ensure your terminal is secure

docs/cli/themes.md

@@ -1,170 +0,0 @@
-# Themes
-
-Gemini CLI supports a variety of themes to customize its color scheme and appearance. You can change the theme to suit your preferences via the `/theme` command or `"theme":` configuration setting.
-
-## Available Themes
-
-Gemini CLI comes with a selection of pre-defined themes, which you can list using the `/theme` command within Gemini CLI:
-
-- **Dark Themes:**
-  - `ANSI`
-  - `Atom One`
-  - `Ayu`
-  - `Default`
-  - `Dracula`
-  - `GitHub`
-- **Light Themes:**
-  - `ANSI Light`
-  - `Ayu Light`
-  - `Default Light`
-  - `GitHub Light`
-  - `Google Code`
-  - `Xcode`
-
-### Changing Themes
-
-1.  Enter `/theme` into Gemini CLI.
-2.  A dialog or selection prompt appears, listing the available themes.
-3.  Using the arrow keys, select a theme. Some interfaces might offer a live preview or highlight as you select.
-4.  Confirm your selection to apply the theme.
-
-### Theme Persistence
-
-Selected themes are saved in Gemini CLI's [configuration](./configuration.md) so your preference is remembered across sessions.
-
----
-
-## Custom Color Themes
-
-Gemini CLI allows you to create your own custom color themes by specifying them in your `settings.json` file. This gives you full control over the color palette used in the CLI.
-
-### How to Define a Custom Theme
-
-Add a `customThemes` block to your user, project, or system `settings.json` file. Each custom theme is defined as an object with a unique name and a set of color keys. For example:
-
-```json
-{
-  "customThemes": {
-    "MyCustomTheme": {
-      "name": "MyCustomTheme",
-      "type": "custom",
-      "Background": "#181818",
-      "Foreground": "#F8F8F2",
-      "LightBlue": "#82AAFF",
-      "AccentBlue": "#61AFEF",
-      "AccentPurple": "#C678DD",
-      "AccentCyan": "#56B6C2",
-      "AccentGreen": "#98C379",
-      "AccentYellow": "#E5C07B",
-      "AccentRed": "#E06C75",
-      "Comment": "#5C6370",
-      "Gray": "#ABB2BF",
-      "DiffAdded": "#A6E3A1",
-      "DiffRemoved": "#F38BA8",
-      "DiffModified": "#89B4FA",
-      "GradientColors": ["#4796E4", "#847ACE", "#C3677F"]
-    }
-  }
-}
-```
-
-**Color keys:**
-
-- `Background`
-- `Foreground`
-- `LightBlue`
-- `AccentBlue`
-- `AccentPurple`
-- `AccentCyan`
-- `AccentGreen`
-- `AccentYellow`
-- `AccentRed`
-- `Comment`
-- `Gray`
-- `DiffAdded` (optional, for added lines in diffs)
-- `DiffRemoved` (optional, for removed lines in diffs)
-- `DiffModified` (optional, for modified lines in diffs)
-
-**Required Properties:**
-
-- `name` (must match the key in the `customThemes` object and be a string)
-- `type` (must be the string `"custom"`)
-- `Background`
-- `Foreground`
-- `LightBlue`
-- `AccentBlue`
-- `AccentPurple`
-- `AccentCyan`
-- `AccentGreen`
-- `AccentYellow`
-- `AccentRed`
-- `Comment`
-- `Gray`
-
-You can use either hex codes (e.g., `#FF0000`) **or** standard CSS color names (e.g., `coral`, `teal`, `blue`) for any color value. See [CSS color names](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value#color_keywords) for a full list of supported names.
-
-You can define multiple custom themes by adding more entries to the `customThemes` object.
-
-### Example Custom Theme
-
-<img src="../assets/theme-custom.png" alt="Custom theme example" width="600" />
-
-### Using Your Custom Theme
-
-- Select your custom theme using the `/theme` command in Gemini CLI. Your custom theme will appear in the theme selection dialog.
-- Or, set it as the default by adding `"theme": "MyCustomTheme"` to your `settings.json`.
-- Custom themes can be set at the user, project, or system level, and follow the same [configuration precedence](./configuration.md) as other settings.
-
----
-
-## Dark Themes
-
-### ANSI
-
-<img src="../assets/theme-ansi.png" alt="ANSI theme" width="600" />
-
-### Atom OneDark
-
-<img src="../assets/theme-atom-one.png" alt="Atom One theme" width="600">
-
-### Ayu
-
-<img src="../assets/theme-ayu.png" alt="Ayu theme" width="600">
-
-### Default
-
-<img src="../assets/theme-default.png" alt="Default theme" width="600">
-
-### Dracula
-
-<img src="../assets/theme-dracula.png" alt="Dracula theme" width="600">
-
-### GitHub
-
-<img src="../assets/theme-github.png" alt="GitHub theme" width="600">
-
-## Light Themes
-
-### ANSI Light
-
-<img src="../assets/theme-ansi-light.png" alt="ANSI Light theme" width="600">
-
-### Ayu Light
-
-<img src="../assets/theme-ayu-light.png" alt="Ayu Light theme" width="600">
-
-### Default Light
-
-<img src="../assets/theme-default-light.png" alt="Default Light theme" width="600">
-
-### GitHub Light
-
-<img src="../assets/theme-github-light.png" alt="GitHub Light theme" width="600">
-
-### Google Code
-
-<img src="../assets/theme-google-light.png" alt="Google Code theme" width="600">
-
-### Xcode
-
-<img src="../assets/theme-xcode-light.png" alt="Xcode Light theme" width="600">

docs/cli/token-caching.md

@@ -1,14 +0,0 @@
-# Token Caching and Cost Optimization
-
-Gemini CLI automatically optimizes API costs through token caching when using API key authentication (Gemini API key or Vertex AI). This feature reuses previous system instructions and context to reduce the number of tokens processed in subsequent requests.
-
-**Token caching is available for:**
-
-- API key users (Gemini API key)
-- Vertex AI users (with project and location setup)
-
-**Token caching is not available for:**
-
-- OAuth users (Google Personal/Enterprise accounts) - the Code Assist API does not support cached content creation at this time
-
-You can view your token usage and cached token savings using the `/stats` command. When cached tokens are available, they will be displayed in the stats output.

docs/cli/tutorials.md

@@ -1,69 +0,0 @@
-# Tutorials
-
-This page contains tutorials for interacting with Gemini CLI.
-
-## Setting up a Model Context Protocol (MCP) server
-
-> [!CAUTION]
-> Before using a third-party MCP server, ensure you trust its source and understand the tools it provides. Your use of third-party servers is at your own risk.
-
-This tutorial demonstrates how to set up a MCP server, using the [GitHub MCP server](https://github.com/github/github-mcp-server) as an example. The GitHub MCP server provides tools for interacting with GitHub repositories, such as creating issues and commenting on pull requests.
-
-### Prerequisites
-
-Before you begin, ensure you have the following installed and configured:
-
-- **Docker:** Install and run [Docker].
-- **GitHub Personal Access Token (PAT):** Create a new [classic] or [fine-grained] PAT with the necessary scopes.
-
-[Docker]: https://www.docker.com/
-[classic]: https://github.com/settings/tokens/new
-[fine-grained]: https://github.com/settings/personal-access-tokens/new
-
-### Guide
-
-#### Configure the MCP server in `settings.json`
-
-In your project's root directory, create or open the [`.qwen/settings.json` file](./configuration.md). Within the file, add the `mcpServers` configuration block, which provides instructions for how to launch the GitHub MCP server.
-
-```json
-{
-  "mcpServers": {
-    "github": {
-      "command": "docker",
-      "args": [
-        "run",
-        "-i",
-        "--rm",
-        "-e",
-        "GITHUB_PERSONAL_ACCESS_TOKEN",
-        "ghcr.io/github/github-mcp-server"
-      ],
-      "env": {
-        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_PERSONAL_ACCESS_TOKEN}"
-      }
-    }
-  }
-}
-```
-
-#### Set your GitHub token
-
-> [!CAUTION]
-> Using a broadly scoped personal access token that has access to personal and private repositories can lead to information from the private repository being leaked into the public repository. We recommend using a fine-grained access token that doesn't share access to both public and private repositories.
-
-Use an environment variable to store your GitHub PAT:
-
-```bash
-GITHUB_PERSONAL_ACCESS_TOKEN="pat_YourActualGitHubTokenHere"
-```
-
-Gemini CLI uses this value in the `mcpServers` configuration that you defined in the `settings.json` file.
-
-#### Launch Gemini CLI and verify the connection
-
-When you launch Gemini CLI, it automatically reads your configuration and launches the GitHub MCP server in the background. You can then use natural language prompts to ask Gemini CLI to perform GitHub actions. For example:
-
-```bash
-"get all open issues assigned to me in the 'foo/bar' repo and prioritize them"
-```

docs/core/index.md

@@ -1,55 +0,0 @@
-# Gemini CLI Core
-
-Gemini CLI's core package (`packages/core`) is the backend portion of Gemini CLI, handling communication with the Gemini API, managing tools, and processing requests sent from `packages/cli`. For a general overview of Gemini CLI, see the [main documentation page](../index.md).
-
-## Navigating this section
-
-- **[Core tools API](./tools-api.md):** Information on how tools are defined, registered, and used by the core.
-- **[Memory Import Processor](./memport.md):** Documentation for the modular GEMINI.md import feature using @file.md syntax.
-
-## Role of the core
-
-While the `packages/cli` portion of Gemini CLI provides the user interface, `packages/core` is responsible for:
-
-- **Gemini API interaction:** Securely communicating with the Google Gemini API, sending user prompts, and receiving model responses.
-- **Prompt engineering:** Constructing effective prompts for the Gemini model, potentially incorporating conversation history, tool definitions, and instructional context from `GEMINI.md` files.
-- **Tool management & orchestration:**
-  - Registering available tools (e.g., file system tools, shell command execution).
-  - Interpreting tool use requests from the Gemini model.
-  - Executing the requested tools with the provided arguments.
-  - Returning tool execution results to the Gemini model for further processing.
-- **Session and state management:** Keeping track of the conversation state, including history and any relevant context required for coherent interactions.
-- **Configuration:** Managing core-specific configurations, such as API key access, model selection, and tool settings.
-
-## Security considerations
-
-The core plays a vital role in security:
-
-- **API key management:** It handles the `GEMINI_API_KEY` and ensures it's used securely when communicating with the Gemini API.
-- **Tool execution:** When tools interact with the local system (e.g., `run_shell_command`), the core (and its underlying tool implementations) must do so with appropriate caution, often involving sandboxing mechanisms to prevent unintended modifications.
-
-## Chat history compression
-
-To ensure that long conversations don't exceed the token limits of the Gemini model, the core includes a chat history compression feature.
-
-When a conversation approaches the token limit for the configured model, the core automatically compresses the conversation history before sending it to the model. This compression is designed to be lossless in terms of the information conveyed, but it reduces the overall number of tokens used.
-
-You can find the token limits for each model in the [Google AI documentation](https://ai.google.dev/gemini-api/docs/models).
-
-## Model fallback
-
-Gemini CLI includes a model fallback mechanism to ensure that you can continue to use the CLI even if the default "pro" model is rate-limited.
-
-If you are using the default "pro" model and the CLI detects that you are being rate-limited, it automatically switches to the "flash" model for the current session. This allows you to continue working without interruption.
-
-## File discovery service
-
-The file discovery service is responsible for finding files in the project that are relevant to the current context. It is used by the `@` command and other tools that need to access files.
-
-## Memory discovery service
-
-The memory discovery service is responsible for finding and loading the `GEMINI.md` files that provide context to the model. It searches for these files in a hierarchical manner, starting from the current working directory and moving up to the project root and the user's home directory. It also searches in subdirectories.
-
-This allows you to have global, project-level, and component-level context files, which are all combined to provide the model with the most relevant information.
-
-You can use the [`/memory` command](../cli/commands.md) to `show`, `add`, and `refresh` the content of loaded `GEMINI.md` files.

docs/core/memport.md

@@ -1,215 +0,0 @@
-# Memory Import Processor
-
-The Memory Import Processor is a feature that allows you to modularize your GEMINI.md files by importing content from other files using the `@file.md` syntax.
-
-## Overview
-
-This feature enables you to break down large GEMINI.md files into smaller, more manageable components that can be reused across different contexts. The import processor supports both relative and absolute paths, with built-in safety features to prevent circular imports and ensure file access security.
-
-## Syntax
-
-Use the `@` symbol followed by the path to the file you want to import:
-
-```markdown
-# Main GEMINI.md file
-
-This is the main content.
-
-@./components/instructions.md
-
-More content here.
-
-@./shared/configuration.md
-```
-
-## Supported Path Formats
-
-### Relative Paths
-
-- `@./file.md` - Import from the same directory
-- `@../file.md` - Import from parent directory
-- `@./components/file.md` - Import from subdirectory
-
-### Absolute Paths
-
-- `@/absolute/path/to/file.md` - Import using absolute path
-
-## Examples
-
-### Basic Import
-
-```markdown
-# My GEMINI.md
-
-Welcome to my project!
-
-@./getting-started.md
-
-## Features
-
-@./features/overview.md
-```
-
-### Nested Imports
-
-The imported files can themselves contain imports, creating a nested structure:
-
-```markdown
-# main.md
-
-@./header.md
-@./content.md
-@./footer.md
-```
-
-```markdown
-# header.md
-
-# Project Header
-
-@./shared/title.md
-```
-
-## Safety Features
-
-### Circular Import Detection
-
-The processor automatically detects and prevents circular imports:
-
-```markdown
-# file-a.md
-
-@./file-b.md
-
-# file-b.md
-
-@./file-a.md <!-- This will be detected and prevented -->
-```
-
-### File Access Security
-
-The `validateImportPath` function ensures that imports are only allowed from specified directories, preventing access to sensitive files outside the allowed scope.
-
-### Maximum Import Depth
-
-To prevent infinite recursion, there's a configurable maximum import depth (default: 5 levels).
-
-## Error Handling
-
-### Missing Files
-
-If a referenced file doesn't exist, the import will fail gracefully with an error comment in the output.
-
-### File Access Errors
-
-Permission issues or other file system errors are handled gracefully with appropriate error messages.
-
-## Code Region Detection
-
-The import processor uses the `marked` library to detect code blocks and inline code spans, ensuring that `@` imports inside these regions are properly ignored. This provides robust handling of nested code blocks and complex Markdown structures.
-
-## Import Tree Structure
-
-The processor returns an import tree that shows the hierarchy of imported files, similar to Claude's `/memory` feature. This helps users debug problems with their GEMINI.md files by showing which files were read and their import relationships.
-
-Example tree structure:
-
-```
-Memory Files
- L project: GEMINI.md
-            L a.md
-              L b.md
-                L c.md
-              L d.md
-                L e.md
-                  L f.md
-            L included.md
-```
-
-The tree preserves the order that files were imported and shows the complete import chain for debugging purposes.
-
-## Comparison to Claude Code's `/memory` (`claude.md`) Approach
-
-Claude Code's `/memory` feature (as seen in `claude.md`) produces a flat, linear document by concatenating all included files, always marking file boundaries with clear comments and path names. It does not explicitly present the import hierarchy, but the LLM receives all file contents and paths, which is sufficient for reconstructing the hierarchy if needed.
-
-Note: The import tree is mainly for clarity during development and has limited relevance to LLM consumption.
-
-## API Reference
-
-### `processImports(content, basePath, debugMode?, importState?)`
-
-Processes import statements in GEMINI.md content.
-
-**Parameters:**
-
-- `content` (string): The content to process for imports
-- `basePath` (string): The directory path where the current file is located
-- `debugMode` (boolean, optional): Whether to enable debug logging (default: false)
-- `importState` (ImportState, optional): State tracking for circular import prevention
-
-**Returns:** Promise<ProcessImportsResult> - Object containing processed content and import tree
-
-### `ProcessImportsResult`
-
-```typescript
-interface ProcessImportsResult {
-  content: string; // The processed content with imports resolved
-  importTree: MemoryFile; // Tree structure showing the import hierarchy
-}
-```
-
-### `MemoryFile`
-
-```typescript
-interface MemoryFile {
-  path: string; // The file path
-  imports?: MemoryFile[]; // Direct imports, in the order they were imported
-}
-```
-
-### `validateImportPath(importPath, basePath, allowedDirectories)`
-
-Validates import paths to ensure they are safe and within allowed directories.
-
-**Parameters:**
-
-- `importPath` (string): The import path to validate
-- `basePath` (string): The base directory for resolving relative paths
-- `allowedDirectories` (string[]): Array of allowed directory paths
-
-**Returns:** boolean - Whether the import path is valid
-
-### `findProjectRoot(startDir)`
-
-Finds the project root by searching for a `.git` directory upwards from the given start directory. Implemented as an **async** function using non-blocking file system APIs to avoid blocking the Node.js event loop.
-
-**Parameters:**
-
-- `startDir` (string): The directory to start searching from
-
-**Returns:** Promise<string> - The project root directory (or the start directory if no `.git` is found)
-
-## Best Practices
-
-1. **Use descriptive file names** for imported components
-2. **Keep imports shallow** - avoid deeply nested import chains
-3. **Document your structure** - maintain a clear hierarchy of imported files
-4. **Test your imports** - ensure all referenced files exist and are accessible
-5. **Use relative paths** when possible for better portability
-
-## Troubleshooting
-
-### Common Issues
-
-1. **Import not working**: Check that the file exists and the path is correct
-2. **Circular import warnings**: Review your import structure for circular references
-3. **Permission errors**: Ensure the files are readable and within allowed directories
-4. **Path resolution issues**: Use absolute paths if relative paths aren't resolving correctly
-
-### Debug Mode
-
-Enable debug mode to see detailed logging of the import process:
-
-```typescript
-const result = await processImports(content, basePath, true);
-```

docs/core/tools-api.md

@@ -1,73 +0,0 @@
-# Gemini CLI Core: Tools API
-
-The Gemini CLI core (`packages/core`) features a robust system for defining, registering, and executing tools. These tools extend the capabilities of the Gemini model, allowing it to interact with the local environment, fetch web content, and perform various actions beyond simple text generation.
-
-## Core Concepts
-
-- **Tool (`tools.ts`):** An interface and base class (`BaseTool`) that defines the contract for all tools. Each tool must have:
-  - `name`: A unique internal name (used in API calls to Gemini).
-  - `displayName`: A user-friendly name.
-  - `description`: A clear explanation of what the tool does, which is provided to the Gemini model.
-  - `parameterSchema`: A JSON schema defining the parameters that the tool accepts. This is crucial for the Gemini model to understand how to call the tool correctly.
-  - `validateToolParams()`: A method to validate incoming parameters.
-  - `getDescription()`: A method to provide a human-readable description of what the tool will do with specific parameters before execution.
-  - `shouldConfirmExecute()`: A method to determine if user confirmation is required before execution (e.g., for potentially destructive operations).
-  - `execute()`: The core method that performs the tool's action and returns a `ToolResult`.
-
-- **`ToolResult` (`tools.ts`):** An interface defining the structure of a tool's execution outcome:
-  - `llmContent`: The factual string content to be included in the history sent back to the LLM for context.
-  - `returnDisplay`: A user-friendly string (often Markdown) or a special object (like `FileDiff`) for display in the CLI.
-
-- **Tool Registry (`tool-registry.ts`):** A class (`ToolRegistry`) responsible for:
-  - **Registering Tools:** Holding a collection of all available built-in tools (e.g., `ReadFileTool`, `ShellTool`).
-  - **Discovering Tools:** It can also discover tools dynamically:
-    - **Command-based Discovery:** If `toolDiscoveryCommand` is configured in settings, this command is executed. It's expected to output JSON describing custom tools, which are then registered as `DiscoveredTool` instances.
-    - **MCP-based Discovery:** If `mcpServerCommand` is configured, the registry can connect to a Model Context Protocol (MCP) server to list and register tools (`DiscoveredMCPTool`).
-  - **Providing Schemas:** Exposing the `FunctionDeclaration` schemas of all registered tools to the Gemini model, so it knows what tools are available and how to use them.
-  - **Retrieving Tools:** Allowing the core to get a specific tool by name for execution.
-
-## Built-in Tools
-
-The core comes with a suite of pre-defined tools, typically found in `packages/core/src/tools/`. These include:
-
-- **File System Tools:**
-  - `LSTool` (`ls.ts`): Lists directory contents.
-  - `ReadFileTool` (`read-file.ts`): Reads the content of a single file. It takes an `absolute_path` parameter, which must be an absolute path.
-  - `WriteFileTool` (`write-file.ts`): Writes content to a file.
-  - `GrepTool` (`grep.ts`): Searches for patterns in files.
-  - `GlobTool` (`glob.ts`): Finds files matching glob patterns.
-  - `EditTool` (`edit.ts`): Performs in-place modifications to files (often requiring confirmation).
-  - `ReadManyFilesTool` (`read-many-files.ts`): Reads and concatenates content from multiple files or glob patterns (used by the `@` command in CLI).
-- **Execution Tools:**
-  - `ShellTool` (`shell.ts`): Executes arbitrary shell commands (requires careful sandboxing and user confirmation).
-- **Web Tools:**
-  - `WebFetchTool` (`web-fetch.ts`): Fetches content from a URL.
-  - `WebSearchTool` (`web-search.ts`): Performs a web search.
-- **Memory Tools:**
-  - `MemoryTool` (`memoryTool.ts`): Interacts with the AI's memory.
-
-Each of these tools extends `BaseTool` and implements the required methods for its specific functionality.
-
-## Tool Execution Flow
-
-1.  **Model Request:** The Gemini model, based on the user's prompt and the provided tool schemas, decides to use a tool and returns a `FunctionCall` part in its response, specifying the tool name and arguments.
-2.  **Core Receives Request:** The core parses this `FunctionCall`.
-3.  **Tool Retrieval:** It looks up the requested tool in the `ToolRegistry`.
-4.  **Parameter Validation:** The tool's `validateToolParams()` method is called.
-5.  **Confirmation (if needed):**
-    - The tool's `shouldConfirmExecute()` method is called.
-    - If it returns details for confirmation, the core communicates this back to the CLI, which prompts the user.
-    - The user's decision (e.g., proceed, cancel) is sent back to the core.
-6.  **Execution:** If validated and confirmed (or if no confirmation is needed), the core calls the tool's `execute()` method with the provided arguments and an `AbortSignal` (for potential cancellation).
-7.  **Result Processing:** The `ToolResult` from `execute()` is received by the core.
-8.  **Response to Model:** The `llmContent` from the `ToolResult` is packaged as a `FunctionResponse` and sent back to the Gemini model so it can continue generating a user-facing response.
-9.  **Display to User:** The `returnDisplay` from the `ToolResult` is sent to the CLI to show the user what the tool did.
-
-## Extending with Custom Tools
-
-While direct programmatic registration of new tools by users isn't explicitly detailed as a primary workflow in the provided files for typical end-users, the architecture supports extension through:
-
-- **Command-based Discovery:** Advanced users or project administrators can define a `toolDiscoveryCommand` in `settings.json`. This command, when run by the Gemini CLI core, should output a JSON array of `FunctionDeclaration` objects. The core will then make these available as `DiscoveredTool` instances. The corresponding `toolCallCommand` would then be responsible for actually executing these custom tools.
-- **MCP Server(s):** For more complex scenarios, one or more MCP servers can be set up and configured via the `mcpServers` setting in `settings.json`. The Gemini CLI core can then discover and use tools exposed by these servers. As mentioned, if you have multiple MCP servers, the tool names will be prefixed with the server name from your configuration (e.g., `serverAlias__actualToolName`).
-
-This tool system provides a flexible and powerful way to augment the Gemini model's capabilities, making the Gemini CLI a versatile assistant for a wide range of tasks.

docs/deployment.md

@@ -1,117 +0,0 @@
-# Gemini CLI Execution and Deployment
-
-This document describes how to run Gemini CLI and explains the deployment architecture that Gemini CLI uses.
-
-## Running Gemini CLI
-
-There are several ways to run Gemini CLI. The option you choose depends on how you intend to use Gemini CLI.
-
----
-
-### 1. Standard installation (Recommended for typical users)
-
-This is the recommended way for end-users to install Gemini CLI. It involves downloading the Gemini CLI package from the NPM registry.
-
-- **Global install:**
-
-  ```bash
-  npm install -g @google/gemini-cli
-  ```
-
-  Then, run the CLI from anywhere:
-
-  ```bash
-  gemini
-  ```
-
-- **NPX execution:**
-
-  ```bash
-  # Execute the latest version from NPM without a global install
-  npx @google/gemini-cli
-  ```
-
----
-
-### 2. Running in a sandbox (Docker/Podman)
-
-For security and isolation, Gemini CLI can be run inside a container. This is the default way that the CLI executes tools that might have side effects.
-
-- **Directly from the Registry:**
-  You can run the published sandbox image directly. This is useful for environments where you only have Docker and want to run the CLI.
-  ```bash
-  # Run the published sandbox image
-  docker run --rm -it us-docker.pkg.dev/gemini-code-dev/gemini-cli/sandbox:0.1.1
-  ```
-- **Using the `--sandbox` flag:**
-  If you have Gemini CLI installed locally (using the standard installation described above), you can instruct it to run inside the sandbox container.
-  ```bash
-  gemini --sandbox -y -p "your prompt here"
-  ```
-
----
-
-### 3. Running from source (Recommended for Gemini CLI contributors)
-
-Contributors to the project will want to run the CLI directly from the source code.
-
-- **Development Mode:**
-  This method provides hot-reloading and is useful for active development.
-  ```bash
-  # From the root of the repository
-  npm run start
-  ```
-- **Production-like mode (Linked package):**
-  This method simulates a global installation by linking your local package. It's useful for testing a local build in a production workflow.
-
-  ```bash
-  # Link the local cli package to your global node_modules
-  npm link packages/cli
-
-  # Now you can run your local version using the `gemini` command
-  gemini
-  ```
-
----
-
-### 4. Running the latest Gemini CLI commit from GitHub
-
-You can run the most recently committed version of Gemini CLI directly from the GitHub repository. This is useful for testing features still in development.
-
-```bash
-# Execute the CLI directly from the main branch on GitHub
-npx https://github.com/google-gemini/gemini-cli
-```
-
-## Deployment architecture
-
-The execution methods described above are made possible by the following architectural components and processes:
-
-**NPM packages**
-
-Gemini CLI project is a monorepo that publishes two core packages to the NPM registry:
-
-- `@google/gemini-cli-core`: The backend, handling logic and tool execution.
-- `@google/gemini-cli`: The user-facing frontend.
-
-These packages are used when performing the standard installation and when running Gemini CLI from the source.
-
-**Build and packaging processes**
-
-There are two distinct build processes used, depending on the distribution channel:
-
-- **NPM publication:** For publishing to the NPM registry, the TypeScript source code in `@google/gemini-cli-core` and `@google/gemini-cli` is transpiled into standard JavaScript using the TypeScript Compiler (`tsc`). The resulting `dist/` directory is what gets published in the NPM package. This is a standard approach for TypeScript libraries.
-
-- **GitHub `npx` execution:** When running the latest version of Gemini CLI directly from GitHub, a different process is triggered by the `prepare` script in `package.json`. This script uses `esbuild` to bundle the entire application and its dependencies into a single, self-contained JavaScript file. This bundle is created on-the-fly on the user's machine and is not checked into the repository.
-
-**Docker sandbox image**
-
-The Docker-based execution method is supported by the `gemini-cli-sandbox` container image. This image is published to a container registry and contains a pre-installed, global version of Gemini CLI.
-
-## Release process
-
-The release process is automated through GitHub Actions. The release workflow performs the following actions:
-
-1.  Build the NPM packages using `tsc`.
-2.  Publish the NPM packages to the artifact registry.
-3.  Create GitHub releases with bundled assets.

docs/developers/_meta.ts

@@ -0,0 +1,27 @@
+export default {
+  'Contribute to Qwen Code': {
+    title: 'Contribute to Qwen Code',
+    type: 'separator',
+  },
+  architecture: 'Architecture',
+  roadmap: 'Roadmap',
+  contributing: 'Contributing Guide',
+  'Qwen Code SDK': {
+    title: 'Agent SDK',
+    type: 'separator',
+  },
+  'sdk-typescript': 'Typescript SDK',
+  'Dive Into Qwen Code': {
+    title: 'Dive Into Qwen Code',
+    type: 'separator',
+  },
+
+  tools: 'Tools',
+
+  extensions: {
+    display: 'hidden',
+  },
+  examples: {
+    display: 'hidden',
+  },
+};

docs/developers/architecture.md

@@ -0,0 +1,95 @@
+# Qwen Code Architecture Overview
+
+This document provides a high-level overview of Qwen Code's architecture.
+
+## Core Components
+
+Qwen Code is primarily composed of two main packages, along with a suite of tools that can be used by the system in the course of handling command-line input:
+
+### 1. CLI Package (`packages/cli`)
+
+**Purpose:** This contains the user-facing portion of Qwen Code, such as handling the initial user input, presenting the final output, and managing the overall user experience.
+
+**Key Functions:**
+
+- **Input Processing:** Handles user input through various methods including direct text entry, slash commands (e.g., `/help`, `/clear`, `/model`), at commands (`@file` for including file content), and exclamation mark commands (`!command` for shell execution).
+- **History Management:** Maintains conversation history and enables features like session resumption.
+- **Display Rendering:** Formats and presents responses to the user in the terminal with syntax highlighting and proper formatting.
+- **Theme and UI Customization:** Supports customizable themes and UI elements for a personalized experience.
+- **Configuration Settings:** Manages various configuration options through JSON settings files, environment variables, and command-line arguments.
+
+### 2. Core Package (`packages/core`)
+
+**Purpose:** This acts as the backend for Qwen Code. It receives requests sent from `packages/cli`, orchestrates interactions with the configured model API, and manages the execution of available tools.
+
+**Key Functions:**
+
+- **API Client:** Communicates with the Qwen model API to send prompts and receive responses.
+- **Prompt Construction:** Builds appropriate prompts for the model, incorporating conversation history and available tool definitions.
+- **Tool Registration and Execution:** Manages the registration of available tools and executes them based on model requests.
+- **State Management:** Maintains conversation and session state information.
+- **Server-side Configuration:** Handles server-side configuration and settings.
+
+### 3. Tools (`packages/core/src/tools/`)
+
+**Purpose:** These are individual modules that extend the capabilities of the Qwen model, allowing it to interact with the local environment (e.g., file system, shell commands, web fetching).
+
+**Interaction:** `packages/core` invokes these tools based on requests from the Qwen model.
+
+**Common Tools Include:**
+
+- **File Operations:** Reading, writing, and editing files
+- **Shell Commands:** Executing system commands with user approval for potentially dangerous operations
+- **Search Tools:** Finding files and searching content within the project
+- **Web Tools:** Fetching content from the web
+- **MCP Integration:** Connecting to Model Context Protocol servers for extended capabilities
+
+## Interaction Flow
+
+A typical interaction with Qwen Code follows this flow:
+
+1.  **User Input:** The user types a prompt or command into the terminal, which is managed by `packages/cli`.
+2.  **Request to Core:** `packages/cli` sends the user's input to `packages/core`.
+3.  **Request Processing:** The core package:
+    - Constructs an appropriate prompt for the configured model API, possibly including conversation history and available tool definitions.
+    - Sends the prompt to the model API.
+4.  **Model API Response:** The model API processes the prompt and returns a response. This response might be a direct answer or a request to use one of the available tools.
+5.  **Tool Execution (if applicable):**
+    - When the model API requests a tool, the core package prepares to execute it.
+    - If the requested tool can modify the file system or execute shell commands, the user is first given details of the tool and its arguments, and the user must approve the execution.
+    - Read-only operations, such as reading files, might not require explicit user confirmation to proceed.
+    - Once confirmed, or if confirmation is not required, the core package executes the relevant action within the relevant tool, and the result is sent back to the model API by the core package.
+    - The model API processes the tool result and generates a final response.
+6.  **Response to CLI:** The core package sends the final response back to the CLI package.
+7.  **Display to User:** The CLI package formats and displays the response to the user in the terminal.
+
+## Configuration Options
+
+Qwen Code offers multiple ways to configure its behavior:
+
+### Configuration Layers (in order of precedence)
+
+1. Command-line arguments
+2. Environment variables
+3. Project settings file (`.qwen/settings.json`)
+4. User settings file (`~/.qwen/settings.json`)
+5. System settings files
+6. Default values
+
+### Key Configuration Categories
+
+- **General Settings:** vim mode, preferred editor, auto-update preferences
+- **UI Settings:** Theme customization, banner visibility, footer display
+- **Model Settings:** Model selection, session turn limits, compression settings
+- **Context Settings:** Context file names, directory inclusion, file filtering
+- **Tool Settings:** Approval modes, sandboxing, tool restrictions
+- **Privacy Settings:** Usage statistics collection
+- **Advanced Settings:** Debug options, custom bug reporting commands
+
+## Key Design Principles
+
+- **Modularity:** Separating the CLI (frontend) from the Core (backend) allows for independent development and potential future extensions (e.g., different frontends for the same backend).
+- **Extensibility:** The tool system is designed to be extensible, allowing new capabilities to be added through custom tools or MCP server integration.
+- **User Experience:** The CLI focuses on providing a rich and interactive terminal experience with features like syntax highlighting, customizable themes, and intuitive command structures.
+- **Security:** Implements approval mechanisms for potentially dangerous operations and sandboxing options to protect the user's system.
+- **Flexibility:** Supports multiple configuration methods and can adapt to different workflows and environments.

docs/developers/contributing.md

@@ -0,0 +1,303 @@
+# How to Contribute
+
+We would love to accept your patches and contributions to this project.
+
+## Contribution Process
+
+### Code Reviews
+
+All submissions, including submissions by project members, require review. We
+use [GitHub pull requests](https://docs.github.com/articles/about-pull-requests)
+for this purpose.
+
+### Pull Request Guidelines
+
+To help us review and merge your PRs quickly, please follow these guidelines. PRs that do not meet these standards may be closed.
+
+#### 1. Link to an Existing Issue
+
+All PRs should be linked to an existing issue in our tracker. This ensures that every change has been discussed and is aligned with the project's goals before any code is written.
+
+- **For bug fixes:** The PR should be linked to the bug report issue.
+- **For features:** The PR should be linked to the feature request or proposal issue that has been approved by a maintainer.
+
+If an issue for your change doesn't exist, please **open one first** and wait for feedback before you start coding.
+
+#### 2. Keep It Small and Focused
+
+We favor small, atomic PRs that address a single issue or add a single, self-contained feature.
+
+- **Do:** Create a PR that fixes one specific bug or adds one specific feature.
+- **Don't:** Bundle multiple unrelated changes (e.g., a bug fix, a new feature, and a refactor) into a single PR.
+
+Large changes should be broken down into a series of smaller, logical PRs that can be reviewed and merged independently.
+
+#### 3. Use Draft PRs for Work in Progress
+
+If you'd like to get early feedback on your work, please use GitHub's **Draft Pull Request** feature. This signals to the maintainers that the PR is not yet ready for a formal review but is open for discussion and initial feedback.
+
+#### 4. Ensure All Checks Pass
+
+Before submitting your PR, ensure that all automated checks are passing by running `npm run preflight`. This command runs all tests, linting, and other style checks.
+
+#### 5. Update Documentation
+
+If your PR introduces a user-facing change (e.g., a new command, a modified flag, or a change in behavior), you must also update the relevant documentation in the `/docs` directory.
+
+#### 6. Write Clear Commit Messages and a Good PR Description
+
+Your PR should have a clear, descriptive title and a detailed description of the changes. Follow the [Conventional Commits](https://www.conventionalcommits.org/) standard for your commit messages.
+
+- **Good PR Title:** `feat(cli): Add --json flag to 'config get' command`
+- **Bad PR Title:** `Made some changes`
+
+In the PR description, explain the "why" behind your changes and link to the relevant issue (e.g., `Fixes #123`).
+
+## Development Setup and Workflow
+
+This section guides contributors on how to build, modify, and understand the development setup of this project.
+
+### Setting Up the Development Environment
+
+**Prerequisites:**
+
+1.  **Node.js**:
+    - **Development:** Please use Node.js `~20.19.0`. This specific version is required due to an upstream development dependency issue. You can use a tool like [nvm](https://github.com/nvm-sh/nvm) to manage Node.js versions.
+    - **Production:** For running the CLI in a production environment, any version of Node.js `>=20` is acceptable.
+2.  **Git**
+
+### Build Process
+
+To clone the repository:
+
+```bash
+git clone https://github.com/QwenLM/qwen-code.git # Or your fork's URL
+cd qwen-code
+```
+
+To install dependencies defined in `package.json` as well as root dependencies:
+
+```bash
+npm install
+```
+
+To build the entire project (all packages):
+
+```bash
+npm run build
+```
+
+This command typically compiles TypeScript to JavaScript, bundles assets, and prepares the packages for execution. Refer to `scripts/build.js` and `package.json` scripts for more details on what happens during the build.
+
+### Enabling Sandboxing
+
+[Sandboxing](#sandboxing) is highly recommended and requires, at a minimum, setting `QWEN_SANDBOX=true` in your `~/.env` and ensuring a sandboxing provider (e.g. `macOS Seatbelt`, `docker`, or `podman`) is available. See [Sandboxing](#sandboxing) for details.
+
+To build both the `qwen-code` CLI utility and the sandbox container, run `build:all` from the root directory:
+
+```bash
+npm run build:all
+```
+
+To skip building the sandbox container, you can use `npm run build` instead.
+
+### Running
+
+To start the Qwen Code application from the source code (after building), run the following command from the root directory:
+
+```bash
+npm start
+```
+
+If you'd like to run the source build outside of the qwen-code folder, you can utilize `npm link path/to/qwen-code/packages/cli` (see: [docs](https://docs.npmjs.com/cli/v9/commands/npm-link)) to run with `qwen-code`
+
+### Running Tests
+
+This project contains two types of tests: unit tests and integration tests.
+
+#### Unit Tests
+
+To execute the unit test suite for the project:
+
+```bash
+npm run test
+```
+
+This will run tests located in the `packages/core` and `packages/cli` directories. Ensure tests pass before submitting any changes. For a more comprehensive check, it is recommended to run `npm run preflight`.
+
+#### Integration Tests
+
+The integration tests are designed to validate the end-to-end functionality of Qwen Code. They are not run as part of the default `npm run test` command.
+
+To run the integration tests, use the following command:
+
+```bash
+npm run test:e2e
+```
+
+For more detailed information on the integration testing framework, please see the [Integration Tests documentation](./docs/integration-tests.md).
+
+### Linting and Preflight Checks
+
+To ensure code quality and formatting consistency, run the preflight check:
+
+```bash
+npm run preflight
+```
+
+This command will run ESLint, Prettier, all tests, and other checks as defined in the project's `package.json`.
+
+_ProTip_
+
+after cloning create a git precommit hook file to ensure your commits are always clean.
+
+```bash
+echo "
+# Run npm build and check for errors
+if ! npm run preflight; then
+  echo "npm build failed. Commit aborted."
+  exit 1
+fi
+" > .git/hooks/pre-commit && chmod +x .git/hooks/pre-commit
+```
+
+#### Formatting
+
+To separately format the code in this project by running the following command from the root directory:
+
+```bash
+npm run format
+```
+
+This command uses Prettier to format the code according to the project's style guidelines.
+
+#### Linting
+
+To separately lint the code in this project, run the following command from the root directory:
+
+```bash
+npm run lint
+```
+
+### Coding Conventions
+
+- Please adhere to the coding style, patterns, and conventions used throughout the existing codebase.
+- **Imports:** Pay special attention to import paths. The project uses ESLint to enforce restrictions on relative imports between packages.
+
+### Project Structure
+
+- `packages/`: Contains the individual sub-packages of the project.
+  - `cli/`: The command-line interface.
+  - `core/`: The core backend logic for Qwen Code.
+- `docs/`: Contains all project documentation.
+- `scripts/`: Utility scripts for building, testing, and development tasks.
+
+For more detailed architecture, see `docs/architecture.md`.
+
+## Documentation Development
+
+This section describes how to develop and preview the documentation locally.
+
+### Prerequisites
+
+1. Ensure you have Node.js (version 18+) installed
+2. Have npm or yarn available
+
+### Setup Documentation Site Locally
+
+To work on the documentation and preview changes locally:
+
+1. Navigate to the `docs-site` directory:
+
+   ```bash
+   cd docs-site
+   ```
+
+2. Install dependencies:
+
+   ```bash
+   npm install
+   ```
+
+3. Link the documentation content from the main `docs` directory:
+
+   ```bash
+   npm run link
+   ```
+
+   This creates a symbolic link from `../docs` to `content` in the docs-site project, allowing the documentation content to be served by the Next.js site.
+
+4. Start the development server:
+
+   ```bash
+   npm run dev
+   ```
+
+5. Open [http://localhost:3000](http://localhost:3000) in your browser to see the documentation site with live updates as you make changes.
+
+Any changes made to the documentation files in the main `docs` directory will be reflected immediately in the documentation site.
+
+## Debugging
+
+### VS Code:
+
+0.  Run the CLI to interactively debug in VS Code with `F5`
+1.  Start the CLI in debug mode from the root directory:
+    ```bash
+    npm run debug
+    ```
+    This command runs `node --inspect-brk dist/index.js` within the `packages/cli` directory, pausing execution until a debugger attaches. You can then open `chrome://inspect` in your Chrome browser to connect to the debugger.
+2.  In VS Code, use the "Attach" launch configuration (found in `.vscode/launch.json`).
+
+Alternatively, you can use the "Launch Program" configuration in VS Code if you prefer to launch the currently open file directly, but 'F5' is generally recommended.
+
+To hit a breakpoint inside the sandbox container run:
+
+```bash
+DEBUG=1 qwen-code
+```
+
+**Note:** If you have `DEBUG=true` in a project's `.env` file, it won't affect qwen-code due to automatic exclusion. Use `.qwen-code/.env` files for qwen-code specific debug settings.
+
+### React DevTools
+
+To debug the CLI's React-based UI, you can use React DevTools. Ink, the library used for the CLI's interface, is compatible with React DevTools version 4.x.
+
+1.  **Start the Qwen Code application in development mode:**
+
+    ```bash
+    DEV=true npm start
+    ```
+
+2.  **Install and run React DevTools version 4.28.5 (or the latest compatible 4.x version):**
+
+    You can either install it globally:
+
+    ```bash
+    npm install -g react-devtools@4.28.5
+    react-devtools
+    ```
+
+    Or run it directly using npx:
+
+    ```bash
+    npx react-devtools@4.28.5
+    ```
+
+    Your running CLI application should then connect to React DevTools.
+
+## Sandboxing
+
+> TBD
+
+## Manual Publish
+
+We publish an artifact for each commit to our internal registry. But if you need to manually cut a local build, then run the following commands:
+
+```
+npm run clean
+npm install
+npm run auth
+npm run prerelease:dev
+npm publish --workspaces
+```

docs/developers/development/_meta.ts

@@ -0,0 +1,9 @@
+export default {
+  npm: 'NPM',
+  telemetry: 'Telemetry',
+  'integration-tests': 'Integration Tests',
+  'issue-and-pr-automation': 'Issue and PR Automation',
+  deployment: {
+    display: 'hidden',
+  },
+};

docs/developers/development/deployment.md

@@ -0,0 +1,117 @@
+# Qwen Code Execution and Deployment
+
+This document describes how to run Qwen Code and explains the deployment architecture that Qwen Code uses.
+
+## Running Qwen Code
+
+There are several ways to run Qwen Code. The option you choose depends on how you intend to use it.
+
+---
+
+### 1. Standard installation (Recommended for typical users)
+
+This is the recommended way for end-users to install Qwen Code. It involves downloading the Qwen Code package from the NPM registry.
+
+- **Global install:**
+
+  ```bash
+  npm install -g @qwen-code/qwen-code
+  ```
+
+  Then, run the CLI from anywhere:
+
+  ```bash
+  qwen
+  ```
+
+- **NPX execution:**
+
+  ```bash
+  # Execute the latest version from NPM without a global install
+  npx @qwen-code/qwen-code
+  ```
+
+---
+
+### 2. Running in a sandbox (Docker/Podman)
+
+For security and isolation, Qwen Code can be run inside a container. This is the default way that the CLI executes tools that might have side effects.
+
+- **Directly from the Registry:**
+  You can run the published sandbox image directly. This is useful for environments where you only have Docker and want to run the CLI.
+  ```bash
+  # Run the published sandbox image
+  docker run --rm -it ghcr.io/qwenlm/qwen-code:0.0.11
+  ```
+- **Using the `--sandbox` flag:**
+  If you have Qwen Code installed locally (using the standard installation described above), you can instruct it to run inside the sandbox container.
+  ```bash
+  qwen --sandbox -y -p "your prompt here"
+  ```
+
+---
+
+### 3. Running from source (Recommended for Qwen Code contributors)
+
+Contributors to the project will want to run the CLI directly from the source code.
+
+- **Development Mode:**
+  This method provides hot-reloading and is useful for active development.
+  ```bash
+  # From the root of the repository
+  npm run start
+  ```
+- **Production-like mode (Linked package):**
+  This method simulates a global installation by linking your local package. It's useful for testing a local build in a production workflow.
+
+  ```bash
+  # Link the local cli package to your global node_modules
+  npm link packages/cli
+
+  # Now you can run your local version using the `qwen` command
+  qwen
+  ```
+
+---
+
+### 4. Running the latest Qwen Code commit from GitHub
+
+You can run the most recently committed version of Qwen Code directly from the GitHub repository. This is useful for testing features still in development.
+
+```bash
+# Execute the CLI directly from the main branch on GitHub
+npx https://github.com/QwenLM/qwen-code
+```
+
+## Deployment architecture
+
+The execution methods described above are made possible by the following architectural components and processes:
+
+**NPM packages**
+
+Qwen Code project is a monorepo that publishes core packages to the NPM registry:
+
+- `@qwen-code/qwen-code-core`: The backend, handling logic and tool execution.
+- `@qwen-code/qwen-code`: The user-facing frontend.
+
+These packages are used when performing the standard installation and when running Qwen Code from the source.
+
+**Build and packaging processes**
+
+There are two distinct build processes used, depending on the distribution channel:
+
+- **NPM publication:** For publishing to the NPM registry, the TypeScript source code in `@qwen-code/qwen-code-core` and `@qwen-code/qwen-code` is transpiled into standard JavaScript using the TypeScript Compiler (`tsc`). The resulting `dist/` directory is what gets published in the NPM package. This is a standard approach for TypeScript libraries.
+
+- **GitHub `npx` execution:** When running the latest version of Qwen Code directly from GitHub, a different process is triggered by the `prepare` script in `package.json`. This script uses `esbuild` to bundle the entire application and its dependencies into a single, self-contained JavaScript file. This bundle is created on-the-fly on the user's machine and is not checked into the repository.
+
+**Docker sandbox image**
+
+The Docker-based execution method is supported by the `qwen-code-sandbox` container image. This image is published to a container registry and contains a pre-installed, global version of Qwen Code.
+
+## Release process
+
+The release process is automated through GitHub Actions. The release workflow performs the following actions:
+
+1.  Build the NPM packages using `tsc`.
+2.  Publish the NPM packages to the artifact registry.
+3.  Create GitHub releases with bundled assets.

docs/developers/development/integration-tests.md

@@ -4,7 +4,7 @@ This document provides information about the integration testing framework used
 
 ## Overview
 
-The integration tests are designed to validate the end-to-end functionality of the Gemini CLI. They execute the built binary in a controlled environment and verify that it behaves as expected when interacting with the file system.
+The integration tests are designed to validate the end-to-end functionality of Qwen Code. They execute the built binary in a controlled environment and verify that it behaves as expected when interacting with the file system.
 
 These tests are located in the `integration-tests` directory and are run using a custom test runner.
 
@@ -20,7 +20,7 @@ npm run test:e2e
 
 ## Running a specific set of tests
 
-To run a subset of test files, you can use `npm run <integration test command> <file_name1> ....` where <integration test command> is either `test:e2e` or `test:integration*` and `<file_name>` is any of the `.test.js` files in the `integration-tests/` directory. For example, the following command runs `list_directory.test.js` and `write_file.test.js`:
+To run a subset of test files, you can use `npm run <integration test command> <file_name1> ....` where &lt;integration test command&gt; is either `test:e2e` or `test:integration*` and `<file_name>` is any of the `.test.js` files in the `integration-tests/` directory. For example, the following command runs `list_directory.test.js` and `write_file.test.js`:
 
 ```bash
 npm run test:e2e list_directory write_file
@@ -67,13 +67,9 @@ The integration test runner provides several options for diagnostics to help tra
 
 You can preserve the temporary files created during a test run for inspection. This is useful for debugging issues with file system operations.
 
-To keep the test output, you can either use the `--keep-output` flag or set the `KEEP_OUTPUT` environment variable to `true`.
+To keep the test output set the `KEEP_OUTPUT` environment variable to `true`.
 
 ```bash
-# Using the flag
-npm run test:integration:sandbox:none -- --keep-output
-
-# Using the environment variable
 KEEP_OUTPUT=true npm run test:integration:sandbox:none
 ```
 
@@ -81,20 +77,20 @@ When output is kept, the test runner will print the path to the unique directory
 
 ### Verbose output
 
-For more detailed debugging, the `--verbose` flag streams the real-time output from the `gemini` command to the console.
+For more detailed debugging, set the `VERBOSE` environment variable to `true`.
 
 ```bash
-npm run test:integration:sandbox:none -- --verbose
+VERBOSE=true npm run test:integration:sandbox:none
 ```
 
-When using `--verbose` and `--keep-output` in the same command, the output is streamed to the console and also saved to a log file within the test's temporary directory.
+When using `VERBOSE=true` and `KEEP_OUTPUT=true` in the same command, the output is streamed to the console and also saved to a log file within the test's temporary directory.
 
 The verbose output is formatted to clearly identify the source of the logs:
 
 ```
---- TEST: <file-name-without-js>:<test-name> ---
-... output from the gemini command ...
---- END TEST: <file-name-without-js>:<test-name> ---
+--- TEST: <log dir>:<test-name> ---
+... output from the qwen command ...
+--- END TEST: <log dir>:<test-name> ---
 ```
 
 ## Linting and formatting
@@ -109,10 +105,10 @@ To check for linting errors, run the following command:
 npm run lint
 ```
 
-You can include the `--fix` flag in the command to automatically fix any fixable linting errors:
+You can include the `:fix` flag in the command to automatically fix any fixable linting errors:
 
 ```bash
-npm run lint --fix
+npm run lint:fix
 ```
 
 ## Directory structure
@@ -134,7 +130,7 @@ This structure makes it easy to locate the artifacts for a specific test run, fi
 
 To ensure the integration tests are always run, a GitHub Actions workflow is defined in `.github/workflows/e2e.yml`. This workflow automatically runs the integrations tests for pull requests against the `main` branch, or when a pull request is added to a merge queue.
 
-The workflow runs the tests in different sandboxing environments to ensure Gemini CLI is tested across each:
+The workflow runs the tests in different sandboxing environments to ensure Qwen Code is tested across each:
 
 - `sandbox:none`: Runs the tests without any sandboxing.
 - `sandbox:docker`: Runs the tests in a Docker container.

docs/developers/development/issue-and-pr-automation.md

@@ -16,10 +16,10 @@ Here is a breakdown of the specific automation workflows that run in our reposit
 
 This is the first bot you will interact with when you create an issue. Its job is to perform an initial analysis and apply the correct labels.
 
-- **Workflow File**: `.github/workflows/gemini-automated-issue-triage.yml`
+- **Workflow File**: `.github/workflows/qwen-automated-issue-triage.yml`
 - **When it runs**: Immediately after an issue is created or reopened.
 - **What it does**:
-  - It uses a Gemini model to analyze the issue's title and body against a detailed set of guidelines.
+  - It uses a Qwen model to analyze the issue's title and body against a detailed set of guidelines.
   - **Applies one `area/*` label**: Categorizes the issue into a functional area of the project (e.g., `area/ux`, `area/models`, `area/platform`).
   - **Applies one `kind/*` label**: Identifies the type of issue (e.g., `kind/bug`, `kind/enhancement`, `kind/question`).
   - **Applies one `priority/*` label**: Assigns a priority from P0 (critical) to P3 (low) based on the described impact.
@@ -47,7 +47,7 @@ This workflow ensures that all changes meet our quality standards before they ca
 
 This workflow runs periodically to ensure all open PRs are correctly linked to issues and have consistent labels.
 
-- **Workflow File**: `.github/workflows/gemini-scheduled-pr-triage.yml`
+- **Workflow File**: `.github/workflows/qwen-scheduled-pr-triage.yml`
 - **When it runs**: Every 15 minutes on all open pull requests.
 - **What it does**:
   - **Checks for a linked issue**: The bot scans your PR description for a keyword that links it to an issue (e.g., `Fixes #123`, `Closes #456`).
@@ -61,17 +61,17 @@ This workflow runs periodically to ensure all open PRs are correctly linked to i
 
 This is a fallback workflow to ensure that no issue gets missed by the triage process.
 
-- **Workflow File**: `.github/workflows/gemini-scheduled-issue-triage.yml`
+- **Workflow File**: `.github/workflows/qwen-scheduled-issue-triage.yml`
 - **When it runs**: Every hour on all open issues.
 - **What it does**:
   - It actively seeks out issues that either have no labels at all or still have the `status/need-triage` label.
-  - It then triggers the same powerful Gemini-based analysis as the initial triage bot to apply the correct labels.
+  - It then triggers the same powerful QwenCode-based analysis as the initial triage bot to apply the correct labels.
 - **What you should do**:
   - You typically don't need to do anything. This workflow is a safety net to ensure every issue is eventually categorized, even if the initial triage fails.
 
 ### 5. Release Automation
 
-This workflow handles the process of packaging and publishing new versions of the Gemini CLI.
+This workflow handles the process of packaging and publishing new versions of Qwen Code.
 
 - **Workflow File**: `.github/workflows/release.yml`
 - **When it runs**: On a daily schedule for "nightly" releases, and manually for official patch/minor releases.

docs/developers/development/npm.md

@@ -1,16 +1,16 @@
 # Package Overview
 
-This monorepo contains two main packages: `@google/gemini-cli` and `@google/gemini-cli-core`.
+This monorepo contains two main packages: `@qwen-code/qwen-code` and `@qwen-code/qwen-code-core`.
 
-## `@google/gemini-cli`
+## `@qwen-code/qwen-code`
 
-This is the main package for the Gemini CLI. It is responsible for the user interface, command parsing, and all other user-facing functionality.
+This is the main package for Qwen Code. It is responsible for the user interface, command parsing, and all other user-facing functionality.
 
-When this package is published, it is bundled into a single executable file. This bundle includes all of the package's dependencies, including `@google/gemini-cli-core`. This means that whether a user installs the package with `npm install -g @google/gemini-cli` or runs it directly with `npx @google/gemini-cli`, they are using this single, self-contained executable.
+When this package is published, it is bundled into a single executable file. This bundle includes all of the package's dependencies, including `@qwen-code/qwen-code-core`. This means that whether a user installs the package with `npm install -g @qwen-code/qwen-code` or runs it directly with `npx @qwen-code/qwen-code`, they are using this single, self-contained executable.
 
-## `@google/gemini-cli-core`
+## `@qwen-code/qwen-code-core`
 
-This package contains the core logic for interacting with the Gemini API. It is responsible for making API requests, handling authentication, and managing the local cache.
+This package contains the core logic for the CLI. It is responsible for making API requests to configured providers, handling authentication, and managing the local cache.
 
 This package is not bundled. When it is published, it is published as a standard Node.js package with its own dependencies. This allows it to be used as a standalone package in other projects, if needed. All transpiled js code in the `dist` folder is included in the package.
 
@@ -20,7 +20,7 @@ This project follows a structured release process to ensure that all packages ar
 
 ## How To Release
 
-Releases are managed through the [release.yml](https://github.com/google-gemini/gemini-cli/actions/workflows/release.yml) GitHub Actions workflow. To perform a manual release for a patch or hotfix:
+Releases are managed through the [release.yml](https://github.com/QwenLM/qwen-code/actions/workflows/release.yml) GitHub Actions workflow. To perform a manual release for a patch or hotfix:
 
 1.  Navigate to the **Actions** tab of the repository.
 2.  Select the **Release** workflow from the list.
@@ -31,50 +31,65 @@ Releases are managed through the [release.yml](https://github.com/google-gemini/
     - **Dry Run**: Leave as `true` to test the workflow without publishing, or set to `false` to perform a live release.
 5.  Click **Run workflow**.
 
-## Nightly Releases
+## Release Types
 
-In addition to manual releases, this project has an automated nightly release process to provide the latest "bleeding edge" version for testing and development.
+The project supports multiple types of releases:
 
-### Process
+### Stable Releases
 
-Every night at midnight UTC, the [Release workflow](https://github.com/google-gemini/gemini-cli/actions/workflows/release.yml) runs automatically on a schedule. It performs the following steps:
+Regular stable releases for production use.
 
-1.  Checks out the latest code from the `main` branch.
+### Preview Releases
+
+Weekly preview releases every Tuesday at 23:59 UTC for early access to upcoming features.
+
+### Nightly Releases
+
+Daily nightly releases at midnight UTC for bleeding-edge development testing.
+
+## Automated Release Schedule
+
+- **Nightly**: Every day at midnight UTC
+- **Preview**: Every Tuesday at 23:59 UTC
+- **Stable**: Manual releases triggered by maintainers
+
+### How to Use Different Release Types
+
+To install the latest version of each type:
+
+```bash
+# Stable (default)
+npm install -g @qwen-code/qwen-code
+
+# Preview
+npm install -g @qwen-code/qwen-code@preview
+
+# Nightly
+npm install -g @qwen-code/qwen-code@nightly
+```
+
+### Release Process Details
+
+Every scheduled or manual release follows these steps:
+
+1.  Checks out the specified code (latest from `main` branch or specific commit).
 2.  Installs all dependencies.
 3.  Runs the full suite of `preflight` checks and integration tests.
-4.  If all tests succeed, it calculates the next nightly version number (e.g., `v0.2.1-nightly.20230101`).
-5.  It then builds and publishes the packages to npm with the `nightly` dist-tag.
-6.  Finally, it creates a GitHub Release for the nightly version.
+4.  If all tests succeed, it calculates the appropriate version number based on release type.
+5.  Builds and publishes the packages to npm with the appropriate dist-tag.
+6.  Creates a GitHub Release for the version.
 
 ### Failure Handling
 
-If any step in the nightly workflow fails, it will automatically create a new issue in the repository with the labels `bug` and `nightly-failure`. The issue will contain a link to the failed workflow run for easy debugging.
-
-### How to Use the Nightly Build
-
-To install the latest nightly build, use the `@nightly` tag:
-
-```bash
-npm install -g @google/gemini-cli@nightly
-```
-
-We also run a Google cloud build called [release-docker.yml](../.gcp/release-docker.yaml). Which publishes the sandbox docker to match your release. This will also be moved to GH and combined with the main release file once service account permissions are sorted out.
-
-### After the Release
-
-After the workflow has successfully completed, you can monitor its progress in the [GitHub Actions tab](https://github.com/google-gemini/gemini-cli/actions/workflows/release.yml). Once complete, you should:
-
-1.  Go to the [pull requests page](https://github.com/google-gemini/gemini-cli/pulls) of the repository.
-2.  Create a new pull request from the `release/vX.Y.Z` branch to `main`.
-3.  Review the pull request (it should only contain version updates in `package.json` files) and merge it. This keeps the version in `main` up-to-date.
+If any step in the release workflow fails, it will automatically create a new issue in the repository with the labels `bug` and a type-specific failure label (e.g., `nightly-failure`, `preview-failure`). The issue will contain a link to the failed workflow run for easy debugging.
 
 ## Release Validation
 
 After pushing a new release smoke testing should be performed to ensure that the packages are working as expected. This can be done by installing the packages locally and running a set of tests to ensure that they are functioning correctly.
 
-- `npx -y @google/gemini-cli@latest --version` to validate the push worked as expected if you were not doing a rc or dev tag
-- `npx -y @google/gemini-cli@<release tag> --version` to validate the tag pushed appropriately
-- _This is destructive locally_ `npm uninstall @google/gemini-cli && npm uninstall -g @google/gemini-cli && npm cache clean --force &&  npm install @google/gemini-cli@<version>`
+- `npx -y @qwen-code/qwen-code@latest --version` to validate the push worked as expected if you were not doing a rc or dev tag
+- `npx -y @qwen-code/qwen-code@<release tag> --version` to validate the tag pushed appropriately
+- _This is destructive locally_ `npm uninstall @qwen-code/qwen-code && npm uninstall -g @qwen-code/qwen-code && npm cache clean --force &&  npm install @qwen-code/qwen-code@<version>`
 - Smoke testing a basic run through of exercising a few llm commands and tools is recommended to ensure that the packages are working as expected. We'll codify this more in the future.
 
 ## When to merge the version change, or not?
@@ -126,7 +141,7 @@ You typically do not merge release branches for pre-releases back into `main`.
 
 If you need to test the release process without actually publishing to NPM or creating a public GitHub release, you can trigger the workflow manually from the GitHub UI.
 
-1.  Go to the [Actions tab](https://github.com/google-gemini/gemini-cli/actions/workflows/release.yml) of the repository.
+1.  Go to the [Actions tab](https://github.com/QwenLM/qwen-code/actions/workflows/release.yml) of the repository.
 2.  Click on the "Run workflow" dropdown.
 3.  Leave the `dry_run` option checked (`true`).
 4.  Click the "Run workflow" button.
@@ -148,14 +163,14 @@ This command will do the following:
 3.  Create the package tarballs that would be published to npm.
 4.  Print a summary of the packages that would be published.
 
-You can then inspect the generated tarballs to ensure that they contain the correct files and that the `package.json` files have been updated correctly. The tarballs will be created in the root of each package's directory (e.g., `packages/cli/google-gemini-cli-0.1.6.tgz`).
+You can then inspect the generated tarballs to ensure that they contain the correct files and that the `package.json` files have been updated correctly. The tarballs will be created in the root of each package's directory (e.g., `packages/cli/qwen-code-0.1.6.tgz`).
 
 By performing a dry run, you can be confident that your changes to the packaging process are correct and that the packages will be published successfully.
 
 ## Release Deep Dive
 
 The main goal of the release process is to take the source code from the packages/ directory, build it, and assemble a
-clean, self-contained package in a temporary `bundle` directory at the root of the project. This `bundle` directory is what
+clean, self-contained package in a temporary `dist` directory at the root of the project. This `dist` directory is what
 actually gets published to NPM.
 
 Here are the key stages:
@@ -177,83 +192,46 @@ Stage 2: Building the Source Code
 - Why: The TypeScript code written during development needs to be converted into plain JavaScript that can be run by
   Node.js. The core package is built first as the cli package depends on it.
 
-Stage 3: Assembling the Final Publishable Package
+Stage 3: Bundling and Assembling the Final Publishable Package
 
-This is the most critical stage where files are moved and transformed into their final state for publishing. A temporary
-`bundle` folder is created at the project root to house the final package contents.
+This is the most critical stage where files are moved and transformed into their final state for publishing. The process uses modern bundling techniques to create the final package.
 
-1.  The `package.json` is Transformed:
-    - What happens: The package.json from packages/cli/ is read, modified, and written into the root `bundle`/ directory.
-    - File movement: packages/cli/package.json -> (in-memory transformation) -> `bundle`/package.json
-    - Why: The final package.json must be different from the one used in development. Key changes include:
-      - Removing devDependencies.
-      - Removing workspace-specific "dependencies": { "@gemini-cli/core": "workspace:\*" } and ensuring the core code is
-        bundled directly into the final JavaScript file.
-      - Ensuring the bin, main, and files fields point to the correct locations within the final package structure.
+1.  Bundle Creation:
+    - What happens: The prepare-package.js script creates a clean distribution package in the `dist` directory.
+    - Key transformations:
+      - Copies README.md and LICENSE to dist/
+      - Copies locales folder for internationalization
+      - Creates a clean package.json for distribution with only necessary dependencies
+      - Includes runtime dependencies like tiktoken
+      - Maintains optional dependencies for node-pty
 
 2.  The JavaScript Bundle is Created:
     - What happens: The built JavaScript from both packages/core/dist and packages/cli/dist are bundled into a single,
-      executable JavaScript file.
-    - File movement: packages/cli/dist/index.js + packages/core/dist/index.js -> (bundled by esbuild) -> `bundle`/gemini.js (or a
-      similar name).
+      executable JavaScript file using esbuild.
+    - File location: dist/cli.js
     - Why: This creates a single, optimized file that contains all the necessary application code. It simplifies the package
-      by removing the need for the core package to be a separate dependency on NPM, as its code is now included directly.
+      by removing the need for complex dependency resolution at install time.
 
 3.  Static and Supporting Files are Copied:
     - What happens: Essential files that are not part of the source code but are required for the package to work correctly
-      or be well-described are copied into the `bundle` directory.
+      or be well-described are copied into the `dist` directory.
     - File movement:
-      - README.md -> `bundle`/README.md
-      - LICENSE -> `bundle`/LICENSE
-      - packages/cli/src/utils/\*.sb (sandbox profiles) -> `bundle`/
+      - README.md -> dist/README.md
+      - LICENSE -> dist/LICENSE
+      - locales/ -> dist/locales/
+      - Vendor files -> dist/vendor/
     - Why:
       - The README.md and LICENSE are standard files that should be included in any NPM package.
-      - The sandbox profiles (.sb files) are critical runtime assets required for the CLI's sandboxing feature to
-        function. They must be located next to the final executable.
+      - Locales support internationalization features
+      - Vendor files contain necessary runtime dependencies
 
 Stage 4: Publishing to NPM
 
-- What happens: The npm publish command is run from inside the root `bundle` directory.
-- Why: By running npm publish from within the `bundle` directory, only the files we carefully assembled in Stage 3 are uploaded
+- What happens: The npm publish command is run from inside the root `dist` directory.
+- Why: By running npm publish from within the `dist` directory, only the files we carefully assembled in Stage 3 are uploaded
   to the NPM registry. This prevents any source code, test files, or development configurations from being accidentally
   published, resulting in a clean and minimal package for users.
 
-Summary of File Flow
-
-```mermaid
-graph TD
-    subgraph "Source Files"
-        A["packages/core/src/*.ts<br/>packages/cli/src/*.ts"]
-        B["packages/cli/package.json"]
-        C["README.md<br/>LICENSE<br/>packages/cli/src/utils/*.sb"]
-    end
-
-    subgraph "Process"
-        D(Build)
-        E(Transform)
-        F(Assemble)
-        G(Publish)
-    end
-
-    subgraph "Artifacts"
-        H["Bundled JS"]
-        I["Final package.json"]
-        J["bundle/"]
-    end
-
-    subgraph "Destination"
-        K["NPM Registry"]
-    end
-
-    A --> D --> H
-    B --> E --> I
-    C --> F
-    H --> F
-    I --> F
-    F --> J
-    J --> G --> K
-```
-
 This process ensures that the final published artifact is a purpose-built, clean, and efficient representation of the
 project, rather than a direct copy of the development workspace.
 
@@ -277,4 +255,4 @@ This tells NPM that any folder inside the `packages` directory is a separate pac
 
 - **Simplified Dependency Management**: Running `npm install` from the root of the project will install all dependencies for all packages in the workspace and link them together. This means you don't need to run `npm install` in each package's directory.
 - **Automatic Linking**: Packages within the workspace can depend on each other. When you run `npm install`, NPM will automatically create symlinks between the packages. This means that when you make changes to one package, the changes are immediately available to other packages that depend on it.
-- **Simplified Script Execution**: You can run scripts in any package from the root of the project using the `--workspace` flag. For example, to run the `build` script in the `cli` package, you can run `npm run build --workspace @google/gemini-cli`.
+- **Simplified Script Execution**: You can run scripts in any package from the root of the project using the `--workspace` flag. For example, to run the `build` script in the `cli` package, you can run `npm run build --workspace @qwen-code/qwen-code`.

docs/developers/development/telemetry.md

@@ -0,0 +1,297 @@
+# Observability with OpenTelemetry
+
+Learn how to enable and setup OpenTelemetry for Qwen Code.
+
+- [Observability with OpenTelemetry](#observability-with-opentelemetry)
+  - [Key Benefits](#key-benefits)
+  - [OpenTelemetry Integration](#opentelemetry-integration)
+  - [Configuration](#configuration)
+  - [Aliyun Telemetry](#aliyun-telemetry)
+    - [Prerequisites](#prerequisites)
+    - [Direct Export (Recommended)](#direct-export-recommended)
+  - [Local Telemetry](#local-telemetry)
+    - [File-based Output (Recommended)](#file-based-output-recommended)
+    - [Collector-Based Export (Advanced)](#collector-based-export-advanced)
+  - [Logs and Metrics](#logs-and-metrics)
+    - [Logs](#logs)
+    - [Metrics](#metrics)
+
+## Key Benefits
+
+- **🔍 Usage Analytics**: Understand interaction patterns and feature adoption
+  across your team
+- **⚡ Performance Monitoring**: Track response times, token consumption, and
+  resource utilization
+- **🐛 Real-time Debugging**: Identify bottlenecks, failures, and error patterns
+  as they occur
+- **📊 Workflow Optimization**: Make informed decisions to improve
+  configurations and processes
+- **🏢 Enterprise Governance**: Monitor usage across teams, track costs, ensure
+  compliance, and integrate with existing monitoring infrastructure
+
+## OpenTelemetry Integration
+
+Built on **[OpenTelemetry]** — the vendor-neutral, industry-standard
+observability framework — Qwen Code's observability system provides:
+
+- **Universal Compatibility**: Export to any OpenTelemetry backend (Aliyun,
+  Jaeger, Prometheus, Datadog, etc.)
+- **Standardized Data**: Use consistent formats and collection methods across
+  your toolchain
+- **Future-Proof Integration**: Connect with existing and future observability
+  infrastructure
+- **No Vendor Lock-in**: Switch between backends without changing your
+  instrumentation
+
+[OpenTelemetry]: https://opentelemetry.io/
+
+## Configuration
+
+> [!note]
+>
+> **⚠️ Special Note: This feature requires corresponding code changes. This documentation is provided in advance; please refer to future code updates for actual functionality.**
+
+All telemetry behavior is controlled through your `.qwen/settings.json` file.
+These settings can be overridden by environment variables or CLI flags.
+
+| Setting        | Environment Variable           | CLI Flag                                                 | Description                                       | Values             | Default                 |
+| -------------- | ------------------------------ | -------------------------------------------------------- | ------------------------------------------------- | ------------------ | ----------------------- |
+| `enabled`      | `QWEN_TELEMETRY_ENABLED`       | `--telemetry` / `--no-telemetry`                         | Enable or disable telemetry                       | `true`/`false`     | `false`                 |
+| `target`       | `QWEN_TELEMETRY_TARGET`        | `--telemetry-target <local\|qwen>`                       | Where to send telemetry data                      | `"qwen"`/`"local"` | `"local"`               |
+| `otlpEndpoint` | `QWEN_TELEMETRY_OTLP_ENDPOINT` | `--telemetry-otlp-endpoint <URL>`                        | OTLP collector endpoint                           | URL string         | `http://localhost:4317` |
+| `otlpProtocol` | `QWEN_TELEMETRY_OTLP_PROTOCOL` | `--telemetry-otlp-protocol <grpc\|http>`                 | OTLP transport protocol                           | `"grpc"`/`"http"`  | `"grpc"`                |
+| `outfile`      | `QWEN_TELEMETRY_OUTFILE`       | `--telemetry-outfile <path>`                             | Save telemetry to file (overrides `otlpEndpoint`) | file path          | -                       |
+| `logPrompts`   | `QWEN_TELEMETRY_LOG_PROMPTS`   | `--telemetry-log-prompts` / `--no-telemetry-log-prompts` | Include prompts in telemetry logs                 | `true`/`false`     | `true`                  |
+| `useCollector` | `QWEN_TELEMETRY_USE_COLLECTOR` | -                                                        | Use external OTLP collector (advanced)            | `true`/`false`     | `false`                 |
+
+**Note on boolean environment variables:** For the boolean settings (`enabled`,
+`logPrompts`, `useCollector`), setting the corresponding environment variable to
+`true` or `1` will enable the feature. Any other value will disable it.
+
+For detailed information about all configuration options, see the
+[Configuration Guide](./cli/configuration.md).
+
+## Aliyun Telemetry
+
+### Direct Export (Recommended)
+
+Sends telemetry directly to Aliyun services. No collector needed.
+
+1. Enable telemetry in your `.qwen/settings.json`:
+   ```json
+   {
+     "telemetry": {
+       "enabled": true,
+       "target": "qwen"
+     }
+   }
+   ```
+2. Run Qwen Code and send prompts.
+3. View logs and metrics in the Aliyun Console.
+
+## Local Telemetry
+
+For local development and debugging, you can capture telemetry data locally:
+
+### File-based Output (Recommended)
+
+1. Enable telemetry in your `.qwen/settings.json`:
+   ```json
+   {
+     "telemetry": {
+       "enabled": true,
+       "target": "local",
+       "otlpEndpoint": "",
+       "outfile": ".qwen/telemetry.log"
+     }
+   }
+   ```
+2. Run Qwen Code and send prompts.
+3. View logs and metrics in the specified file (e.g., `.qwen/telemetry.log`).
+
+### Collector-Based Export (Advanced)
+
+1. Run the automation script:
+   ```bash
+   npm run telemetry -- --target=local
+   ```
+   This will:
+   - Download and start Jaeger and OTEL collector
+   - Configure your workspace for local telemetry
+   - Provide a Jaeger UI at http://localhost:16686
+   - Save logs/metrics to `~/.qwen/tmp/<projectHash>/otel/collector.log`
+   - Stop collector on exit (e.g. `Ctrl+C`)
+2. Run Qwen Code and send prompts.
+3. View traces at http://localhost:16686 and logs/metrics in the collector log
+   file.
+
+## Logs and Metrics
+
+The following section describes the structure of logs and metrics generated for
+Qwen Code.
+
+- A `sessionId` is included as a common attribute on all logs and metrics.
+
+### Logs
+
+Logs are timestamped records of specific events. The following events are logged for Qwen Code:
+
+- `qwen-code.config`: This event occurs once at startup with the CLI's configuration.
+  - **Attributes**:
+    - `model` (string)
+    - `embedding_model` (string)
+    - `sandbox_enabled` (boolean)
+    - `core_tools_enabled` (string)
+    - `approval_mode` (string)
+    - `api_key_enabled` (boolean)
+    - `vertex_ai_enabled` (boolean)
+    - `code_assist_enabled` (boolean)
+    - `log_prompts_enabled` (boolean)
+    - `file_filtering_respect_git_ignore` (boolean)
+    - `debug_mode` (boolean)
+    - `mcp_servers` (string)
+    - `output_format` (string: "text" or "json")
+
+- `qwen-code.user_prompt`: This event occurs when a user submits a prompt.
+  - **Attributes**:
+    - `prompt_length` (int)
+    - `prompt_id` (string)
+    - `prompt` (string, this attribute is excluded if `log_prompts_enabled` is
+      configured to be `false`)
+    - `auth_type` (string)
+
+- `qwen-code.tool_call`: This event occurs for each function call.
+  - **Attributes**:
+    - `function_name`
+    - `function_args`
+    - `duration_ms`
+    - `success` (boolean)
+    - `decision` (string: "accept", "reject", "auto_accept", or "modify", if
+      applicable)
+    - `error` (if applicable)
+    - `error_type` (if applicable)
+    - `content_length` (int, if applicable)
+    - `metadata` (if applicable, dictionary of string -> any)
+
+- `qwen-code.file_operation`: This event occurs for each file operation.
+  - **Attributes**:
+    - `tool_name` (string)
+    - `operation` (string: "create", "read", "update")
+    - `lines` (int, if applicable)
+    - `mimetype` (string, if applicable)
+    - `extension` (string, if applicable)
+    - `programming_language` (string, if applicable)
+    - `diff_stat` (json string, if applicable): A JSON string with the following members:
+      - `ai_added_lines` (int)
+      - `ai_removed_lines` (int)
+      - `user_added_lines` (int)
+      - `user_removed_lines` (int)
+
+- `qwen-code.api_request`: This event occurs when making a request to Qwen API.
+  - **Attributes**:
+    - `model`
+    - `request_text` (if applicable)
+
+- `qwen-code.api_error`: This event occurs if the API request fails.
+  - **Attributes**:
+    - `model`
+    - `error`
+    - `error_type`
+    - `status_code`
+    - `duration_ms`
+    - `auth_type`
+
+- `qwen-code.api_response`: This event occurs upon receiving a response from Qwen API.
+  - **Attributes**:
+    - `model`
+    - `status_code`
+    - `duration_ms`
+    - `error` (optional)
+    - `input_token_count`
+    - `output_token_count`
+    - `cached_content_token_count`
+    - `thoughts_token_count`
+    - `tool_token_count`
+    - `response_text` (if applicable)
+    - `auth_type`
+
+- `qwen-code.tool_output_truncated`: This event occurs when the output of a tool call is too large and gets truncated.
+  - **Attributes**:
+    - `tool_name` (string)
+    - `original_content_length` (int)
+    - `truncated_content_length` (int)
+    - `threshold` (int)
+    - `lines` (int)
+    - `prompt_id` (string)
+
+- `qwen-code.malformed_json_response`: This event occurs when a `generateJson` response from Qwen API cannot be parsed as a json.
+  - **Attributes**:
+    - `model`
+
+- `qwen-code.flash_fallback`: This event occurs when Qwen Code switches to flash as fallback.
+  - **Attributes**:
+    - `auth_type`
+
+- `qwen-code.slash_command`: This event occurs when a user executes a slash command.
+  - **Attributes**:
+    - `command` (string)
+    - `subcommand` (string, if applicable)
+
+- `qwen-code.extension_enable`: This event occurs when an extension is enabled
+- `qwen-code.extension_install`: This event occurs when an extension is installed
+  - **Attributes**:
+    - `extension_name` (string)
+    - `extension_version` (string)
+    - `extension_source` (string)
+    - `status` (string)
+- `qwen-code.extension_uninstall`: This event occurs when an extension is uninstalled
+
+### Metrics
+
+Metrics are numerical measurements of behavior over time. The following metrics are collected for Qwen Code (metric names remain `qwen-code.*` for compatibility):
+
+- `qwen-code.session.count` (Counter, Int): Incremented once per CLI startup.
+
+- `qwen-code.tool.call.count` (Counter, Int): Counts tool calls.
+  - **Attributes**:
+    - `function_name`
+    - `success` (boolean)
+    - `decision` (string: "accept", "reject", or "modify", if applicable)
+    - `tool_type` (string: "mcp", or "native", if applicable)
+
+- `qwen-code.tool.call.latency` (Histogram, ms): Measures tool call latency.
+  - **Attributes**:
+    - `function_name`
+    - `decision` (string: "accept", "reject", or "modify", if applicable)
+
+- `qwen-code.api.request.count` (Counter, Int): Counts all API requests.
+  - **Attributes**:
+    - `model`
+    - `status_code`
+    - `error_type` (if applicable)
+
+- `qwen-code.api.request.latency` (Histogram, ms): Measures API request latency.
+  - **Attributes**:
+    - `model`
+
+- `qwen-code.token.usage` (Counter, Int): Counts the number of tokens used.
+  - **Attributes**:
+    - `model`
+    - `type` (string: "input", "output", "thought", "cache", or "tool")
+
+- `qwen-code.file.operation.count` (Counter, Int): Counts file operations.
+  - **Attributes**:
+    - `operation` (string: "create", "read", "update"): The type of file operation.
+    - `lines` (Int, if applicable): Number of lines in the file.
+    - `mimetype` (string, if applicable): Mimetype of the file.
+    - `extension` (string, if applicable): File extension of the file.
+    - `model_added_lines` (Int, if applicable): Number of lines added/changed by the model.
+    - `model_removed_lines` (Int, if applicable): Number of lines removed/changed by the model.
+    - `user_added_lines` (Int, if applicable): Number of lines added/changed by user in AI proposed changes.
+    - `user_removed_lines` (Int, if applicable): Number of lines removed/changed by user in AI proposed changes.
+    - `programming_language` (string, if applicable): The programming language of the file.
+
+- `qwen-code.chat_compression` (Counter, Int): Counts chat compression operations
+  - **Attributes**:
+    - `tokens_before`: (Int): Number of tokens in context prior to compression
+    - `tokens_after`: (Int): Number of tokens in context after compression

docs/developers/examples/proxy-script.md

@@ -15,10 +15,10 @@ The following is an example of a proxy script that can be used with the `GEMINI_
 // Set `GEMINI_SANDBOX_PROXY_COMMAND=scripts/example-proxy.js` to run proxy alongside sandbox
 // Test via `curl https://example.com` inside sandbox (in shell mode or via shell tool)
 
-import http from 'http';
-import net from 'net';
-import { URL } from 'url';
-import console from 'console';
+import http from 'node:http';
+import net from 'node:net';
+import { URL } from 'node:url';
+import console from 'node:console';
 
 const PROXY_PORT = 8877;
 const ALLOWED_DOMAINS = ['example.com', 'googleapis.com'];

docs/developers/extensions/extension-releasing.md

@@ -0,0 +1,121 @@
+# Extension Releasing
+
+There are two primary ways of releasing extensions to users:
+
+- [Git repository](#releasing-through-a-git-repository)
+- [Github Releases](#releasing-through-github-releases)
+
+Git repository releases tend to be the simplest and most flexible approach, while GitHub releases can be more efficient on initial install as they are shipped as single archives instead of requiring a git clone which downloads each file individually. Github releases may also contain platform specific archives if you need to ship platform specific binary files.
+
+## Releasing through a git repository
+
+This is the most flexible and simple option. All you need to do us create a publicly accessible git repo (such as a public github repository) and then users can install your extension using `qwen extensions install <your-repo-uri>`, or for a GitHub repository they can use the simplified `qwen extensions install <org>/<repo>` format. They can optionally depend on a specific ref (branch/tag/commit) using the `--ref=<some-ref>` argument, this defaults to the default branch.
+
+Whenever commits are pushed to the ref that a user depends on, they will be prompted to update the extension. Note that this also allows for easy rollbacks, the HEAD commit is always treated as the latest version regardless of the actual version in the `qwen-extension.json` file.
+
+### Managing release channels using a git repository
+
+Users can depend on any ref from your git repo, such as a branch or tag, which allows you to manage multiple release channels.
+
+For instance, you can maintain a `stable` branch, which users can install this way `qwen extensions install <your-repo-uri> --ref=stable`. Or, you could make this the default by treating your default branch as your stable release branch, and doing development in a different branch (for instance called `dev`). You can maintain as many branches or tags as you like, providing maximum flexibility for you and your users.
+
+Note that these `ref` arguments can be tags, branches, or even specific commits, which allows users to depend on a specific version of your extension. It is up to you how you want to manage your tags and branches.
+
+### Example releasing flow using a git repo
+
+While there are many options for how you want to manage releases using a git flow, we recommend treating your default branch as your "stable" release branch. This means that the default behavior for `qwen extensions install <your-repo-uri>` is to be on the stable release branch.
+
+Lets say you want to maintain three standard release channels, `stable`, `preview`, and `dev`. You would do all your standard development in the `dev` branch. When you are ready to do a preview release, you merge that branch into your `preview` branch. When you are ready to promote your preview branch to stable, you merge `preview` into your stable branch (which might be your default branch or a different branch).
+
+You can also cherry pick changes from one branch into another using `git cherry-pick`, but do note that this will result in your branches having a slightly divergent history from each other, unless you force push changes to your branches on each release to restore the history to a clean slate (which may not be possible for the default branch depending on your repository settings). If you plan on doing cherry picks, you may want to avoid having your default branch be the stable branch to avoid force-pushing to the default branch which should generally be avoided.
+
+## Releasing through Github releases
+
+Qwen Code extensions can be distributed through [GitHub Releases](https://docs.github.com/en/repositories/releasing-projects-on-github/about-releases). This provides a faster and more reliable initial installation experience for users, as it avoids the need to clone the repository.
+
+Each release includes at least one archive file, which contains the full contents of the repo at the tag that it was linked to. Releases may also include [pre-built archives](#custom-pre-built-archives) if your extension requires some build step or has platform specific binaries attached to it.
+
+When checking for updates, qwen code will just look for the latest release on github (you must mark it as such when creating the release), unless the user installed a specific release by passing `--ref=<some-release-tag>`. We do not at this time support opting in to pre-release releases or semver.
+
+### Custom pre-built archives
+
+Custom archives must be attached directly to the github release as assets and must be fully self-contained. This means they should include the entire extension, see [archive structure](#archive-structure).
+
+If your extension is platform-independent, you can provide a single generic asset. In this case, there should be only one asset attached to the release.
+
+Custom archives may also be used if you want to develop your extension within a larger repository, you can build an archive which has a different layout from the repo itself (for instance it might just be an archive of a subdirectory containing the extension).
+
+#### Platform specific archives
+
+To ensure Qwen Code can automatically find the correct release asset for each platform, you must follow this naming convention. The CLI will search for assets in the following order:
+
+1.  **Platform and Architecture-Specific:** `{platform}.{arch}.{name}.{extension}`
+2.  **Platform-Specific:** `{platform}.{name}.{extension}`
+3.  **Generic:** If only one asset is provided, it will be used as a generic fallback.
+
+- `{name}`: The name of your extension.
+- `{platform}`: The operating system. Supported values are:
+  - `darwin` (macOS)
+  - `linux`
+  - `win32` (Windows)
+- `{arch}`: The architecture. Supported values are:
+  - `x64`
+  - `arm64`
+- `{extension}`: The file extension of the archive (e.g., `.tar.gz` or `.zip`).
+
+**Examples:**
+
+- `darwin.arm64.my-tool.tar.gz` (specific to Apple Silicon Macs)
+- `darwin.my-tool.tar.gz` (for all Macs)
+- `linux.x64.my-tool.tar.gz`
+- `win32.my-tool.zip`
+
+#### Archive structure
+
+Archives must be fully contained extensions and have all the standard requirements - specifically the `qwen-extension.json` file must be at the root of the archive.
+
+The rest of the layout should look exactly the same as a typical extension, see [extensions.md](extension.md).
+
+#### Example GitHub Actions workflow
+
+Here is an example of a GitHub Actions workflow that builds and releases a Qwen Code extension for multiple platforms:
+
+```yaml
+name: Release Extension
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build extension
+        run: npm run build
+
+      - name: Create release assets
+        run: |
+          npm run package -- --platform=darwin --arch=arm64
+          npm run package -- --platform=linux --arch=x64
+          npm run package -- --platform=win32 --arch=x64
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: |
+            release/darwin.arm64.my-tool.tar.gz
+            release/linux.arm64.my-tool.tar.gz
+            release/win32.arm64.my-tool.zip
+```

docs/developers/extensions/extension.md

@@ -0,0 +1,158 @@
+# Qwen Code Extensions
+
+Qwen Code extensions package prompts, MCP servers, and custom commands into a familiar and user-friendly format. With extensions, you can expand the capabilities of Qwen Code and share those capabilities with others. They are designed to be easily installable and shareable.
+
+## Extension management
+
+We offer a suite of extension management tools using `qwen extensions` commands.
+
+Note that these commands are not supported from within the CLI, although you can list installed extensions using the `/extensions list` subcommand.
+
+Note that all of these commands will only be reflected in active CLI sessions on restart.
+
+### Installing an extension
+
+You can install an extension using `qwen extensions install` with either a GitHub URL or a local path`.
+
+Note that we create a copy of the installed extension, so you will need to run `qwen extensions update` to pull in changes from both locally-defined extensions and those on GitHub.
+
+```
+qwen extensions install https://github.com/qwen-cli-extensions/security
+```
+
+This will install the Qwen Code Security extension, which offers support for a `/security:analyze` command.
+
+### Uninstalling an extension
+
+To uninstall, run `qwen extensions uninstall extension-name`, so, in the case of the install example:
+
+```
+qwen extensions uninstall qwen-cli-security
+```
+
+### Disabling an extension
+
+Extensions are, by default, enabled across all workspaces. You can disable an extension entirely or for specific workspace.
+
+For example, `qwen extensions disable extension-name` will disable the extension at the user level, so it will be disabled everywhere. `qwen extensions disable extension-name --scope=workspace` will only disable the extension in the current workspace.
+
+### Enabling an extension
+
+You can enable extensions using `qwen extensions enable extension-name`. You can also enable an extension for a specific workspace using `qwen extensions enable extension-name --scope=workspace` from within that workspace.
+
+This is useful if you have an extension disabled at the top-level and only enabled in specific places.
+
+### Updating an extension
+
+For extensions installed from a local path or a git repository, you can explicitly update to the latest version (as reflected in the `qwen-extension.json` `version` field) with `qwen extensions update extension-name`.
+
+You can update all extensions with:
+
+```
+qwen extensions update --all
+```
+
+## Extension creation
+
+We offer commands to make extension development easier.
+
+### Create a boilerplate extension
+
+We offer several example extensions `context`, `custom-commands`, `exclude-tools` and `mcp-server`. You can view these examples [here](https://github.com/QwenLM/qwen-code/tree/main/packages/cli/src/commands/extensions/examples).
+
+To copy one of these examples into a development directory using the type of your choosing, run:
+
+```
+qwen extensions new path/to/directory custom-commands
+```
+
+### Link a local extension
+
+The `qwen extensions link` command will create a symbolic link from the extension installation directory to the development path.
+
+This is useful so you don't have to run `qwen extensions update` every time you make changes you'd like to test.
+
+```
+qwen extensions link path/to/directory
+```
+
+## How it works
+
+On startup, Qwen Code looks for extensions in `<home>/.qwen/extensions`
+
+Extensions exist as a directory that contains a `qwen-extension.json` file. For example:
+
+`<home>/.qwen/extensions/my-extension/qwen-extension.json`
+
+### `qwen-extension.json`
+
+The `qwen-extension.json` file contains the configuration for the extension. The file has the following structure:
+
+```json
+{
+  "name": "my-extension",
+  "version": "1.0.0",
+  "mcpServers": {
+    "my-server": {
+      "command": "node my-server.js"
+    }
+  },
+  "contextFileName": "QWEN.md",
+  "excludeTools": ["run_shell_command"]
+}
+```
+
+- `name`: The name of the extension. This is used to uniquely identify the extension and for conflict resolution when extension commands have the same name as user or project commands. The name should be lowercase or numbers and use dashes instead of underscores or spaces. This is how users will refer to your extension in the CLI. Note that we expect this name to match the extension directory name.
+- `version`: The version of the extension.
+- `mcpServers`: A map of MCP servers to configure. The key is the name of the server, and the value is the server configuration. These servers will be loaded on startup just like MCP servers configured in a [`settings.json` file](./cli/configuration.md). If both an extension and a `settings.json` file configure an MCP server with the same name, the server defined in the `settings.json` file takes precedence.
+  - Note that all MCP server configuration options are supported except for `trust`.
+- `contextFileName`: The name of the file that contains the context for the extension. This will be used to load the context from the extension directory. If this property is not used but a `QWEN.md` file is present in your extension directory, then that file will be loaded.
+- `excludeTools`: An array of tool names to exclude from the model. You can also specify command-specific restrictions for tools that support it, like the `run_shell_command` tool. For example, `"excludeTools": ["run_shell_command(rm -rf)"]` will block the `rm -rf` command. Note that this differs from the MCP server `excludeTools` functionality, which can be listed in the MCP server config. **Important:** Tools specified in `excludeTools` will be disabled for the entire conversation context and will affect all subsequent queries in the current session.
+
+When Qwen Code starts, it loads all the extensions and merges their configurations. If there are any conflicts, the workspace configuration takes precedence.
+
+### Custom commands
+
+Extensions can provide [custom commands](./cli/commands.md#custom-commands) by placing TOML files in a `commands/` subdirectory within the extension directory. These commands follow the same format as user and project custom commands and use standard naming conventions.
+
+**Example**
+
+An extension named `gcp` with the following structure:
+
+```
+.qwen/extensions/gcp/
+├── qwen-extension.json
+└── commands/
+    ├── deploy.toml
+    └── gcs/
+        └── sync.toml
+```
+
+Would provide these commands:
+
+- `/deploy` - Shows as `[gcp] Custom command from deploy.toml` in help
+- `/gcs:sync` - Shows as `[gcp] Custom command from sync.toml` in help
+
+### Conflict resolution
+
+Extension commands have the lowest precedence. When a conflict occurs with user or project commands:
+
+1. **No conflict**: Extension command uses its natural name (e.g., `/deploy`)
+2. **With conflict**: Extension command is renamed with the extension prefix (e.g., `/gcp.deploy`)
+
+For example, if both a user and the `gcp` extension define a `deploy` command:
+
+- `/deploy` - Executes the user's deploy command
+- `/gcp.deploy` - Executes the extension's deploy command (marked with `[gcp]` tag)
+
+## Variables
+
+Qwen Code extensions allow variable substitution in `qwen-extension.json`. This can be useful if e.g., you need the current directory to run an MCP server using `"cwd": "${extensionPath}${/}run.ts"`.
+
+**Supported variables:**
+
+| variable                   | description                                                                                                                                                   |
+| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `${extensionPath}`         | The fully-qualified path of the extension in the user's filesystem e.g., '/Users/username/.qwen/extensions/example-extension'. This will not unwrap symlinks. |
+| `${workspacePath}`         | The fully-qualified path of the current workspace.                                                                                                            |
+| `${/} or ${pathSeparator}` | The path separator (differs per OS).                                                                                                                          |

docs/developers/extensions/getting-started-extensions.md

@@ -0,0 +1,213 @@
+# Getting Started with Qwen Code Extensions
+
+This guide will walk you through creating your first Qwen Code extension. You'll learn how to set up a new extension, add a custom tool via an MCP server, create a custom command, and provide context to the model with a `QWEN.md` file.
+
+## Prerequisites
+
+Before you start, make sure you have the Qwen Code installed and a basic understanding of Node.js and TypeScript.
+
+## Step 1: Create a New Extension
+
+The easiest way to start is by using one of the built-in templates. We'll use the `mcp-server` example as our foundation.
+
+Run the following command to create a new directory called `my-first-extension` with the template files:
+
+```bash
+qwen extensions new my-first-extension mcp-server
+```
+
+This will create a new directory with the following structure:
+
+```
+my-first-extension/
+├── example.ts
+├── qwen-extension.json
+├── package.json
+└── tsconfig.json
+```
+
+## Step 2: Understand the Extension Files
+
+Let's look at the key files in your new extension.
+
+### `qwen-extension.json`
+
+This is the manifest file for your extension. It tells Qwen Code how to load and use your extension.
+
+```json
+{
+  "name": "my-first-extension",
+  "version": "1.0.0",
+  "mcpServers": {
+    "nodeServer": {
+      "command": "node",
+      "args": ["${extensionPath}${/}dist${/}example.js"],
+      "cwd": "${extensionPath}"
+    }
+  }
+}
+```
+
+- `name`: The unique name for your extension.
+- `version`: The version of your extension.
+- `mcpServers`: This section defines one or more Model Context Protocol (MCP) servers. MCP servers are how you can add new tools for the model to use.
+  - `command`, `args`, `cwd`: These fields specify how to start your server. Notice the use of the `${extensionPath}` variable, which Qwen Code replaces with the absolute path to your extension's installation directory. This allows your extension to work regardless of where it's installed.
+
+### `example.ts`
+
+This file contains the source code for your MCP server. It's a simple Node.js server that uses the `@modelcontextprotocol/sdk`.
+
+```typescript
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+const server = new McpServer({
+  name: 'prompt-server',
+  version: '1.0.0',
+});
+
+// Registers a new tool named 'fetch_posts'
+server.registerTool(
+  'fetch_posts',
+  {
+    description: 'Fetches a list of posts from a public API.',
+    inputSchema: z.object({}).shape,
+  },
+  async () => {
+    const apiResponse = await fetch(
+      'https://jsonplaceholder.typicode.com/posts',
+    );
+    const posts = await apiResponse.json();
+    const response = { posts: posts.slice(0, 5) };
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(response),
+        },
+      ],
+    };
+  },
+);
+
+// ... (prompt registration omitted for brevity)
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+```
+
+This server defines a single tool called `fetch_posts` that fetches data from a public API.
+
+### `package.json` and `tsconfig.json`
+
+These are standard configuration files for a TypeScript project. The `package.json` file defines dependencies and a `build` script, and `tsconfig.json` configures the TypeScript compiler.
+
+## Step 3: Build and Link Your Extension
+
+Before you can use the extension, you need to compile the TypeScript code and link the extension to your Qwen Code installation for local development.
+
+1.  **Install dependencies:**
+
+    ```bash
+    cd my-first-extension
+    npm install
+    ```
+
+2.  **Build the server:**
+
+    ```bash
+    npm run build
+    ```
+
+    This will compile `example.ts` into `dist/example.js`, which is the file referenced in your `qwen-extension.json`.
+
+3.  **Link the extension:**
+
+    The `link` command creates a symbolic link from the Qwen Code extensions directory to your development directory. This means any changes you make will be reflected immediately without needing to reinstall.
+
+    ```bash
+    qwen extensions link .
+    ```
+
+Now, restart your Qwen Code session. The new `fetch_posts` tool will be available. You can test it by asking: "fetch posts".
+
+## Step 4: Add a Custom Command
+
+Custom commands provide a way to create shortcuts for complex prompts. Let's add a command that searches for a pattern in your code.
+
+1.  Create a `commands` directory and a subdirectory for your command group:
+
+    ```bash
+    mkdir -p commands/fs
+    ```
+
+2.  Create a file named `commands/fs/grep-code.toml`:
+
+    ```toml
+    prompt = """
+    Please summarize the findings for the pattern `{{args}}`.
+
+    Search Results:
+    !{grep -r {{args}} .}
+    """
+    ```
+
+    This command, `/fs:grep-code`, will take an argument, run the `grep` shell command with it, and pipe the results into a prompt for summarization.
+
+After saving the file, restart the Qwen Code. You can now run `/fs:grep-code "some pattern"` to use your new command.
+
+## Step 5: Add a Custom `QWEN.md`
+
+You can provide persistent context to the model by adding a `QWEN.md` file to your extension. This is useful for giving the model instructions on how to behave or information about your extension's tools. Note that you may not always need this for extensions built to expose commands and prompts.
+
+1.  Create a file named `QWEN.md` in the root of your extension directory:
+
+    ```markdown
+    # My First Extension Instructions
+
+    You are an expert developer assistant. When the user asks you to fetch posts, use the `fetch_posts` tool. Be concise in your responses.
+    ```
+
+2.  Update your `qwen-extension.json` to tell the CLI to load this file:
+
+    ```json
+    {
+      "name": "my-first-extension",
+      "version": "1.0.0",
+      "contextFileName": "QWEN.md",
+      "mcpServers": {
+        "nodeServer": {
+          "command": "node",
+          "args": ["${extensionPath}${/}dist${/}example.js"],
+          "cwd": "${extensionPath}"
+        }
+      }
+    }
+    ```
+
+Restart the CLI again. The model will now have the context from your `QWEN.md` file in every session where the extension is active.
+
+## Step 6: Releasing Your Extension
+
+Once you are happy with your extension, you can share it with others. The two primary ways of releasing extensions are via a Git repository or through GitHub Releases. Using a public Git repository is the simplest method.
+
+For detailed instructions on both methods, please refer to the [Extension Releasing Guide](extension-releasing.md).
+
+## Conclusion
+
+You've successfully created a Qwen Code extension! You learned how to:
+
+- Bootstrap a new extension from a template.
+- Add custom tools with an MCP server.
+- Create convenient custom commands.
+- Provide persistent context to the model.
+- Link your extension for local development.
+
+From here, you can explore more advanced features and build powerful new capabilities into the Qwen Code.

docs/developers/roadmap.md

@@ -0,0 +1,74 @@
+# Qwen Code RoadMap
+
+> **Objective**: Catch up with Claude Code's product functionality, continuously refine details, and enhance user experience.
+
+| Category                        | Phase 1                                                                                                                                                                            | Phase 2                                                                                           |
+| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
+| User Experience                 | ✅ Terminal UI<br>✅ Support OpenAI Protocol<br>✅ Settings<br>✅ OAuth<br>✅ Cache Control<br>✅ Memory<br>✅ Compress<br>✅ Theme                                                | Better UI<br>OnBoarding<br>LogView<br>✅ Session<br>Permission<br>🔄 Cross-platform Compatibility |
+| Coding Workflow                 | ✅ Slash Commands<br>✅ MCP<br>✅ PlanMode<br>✅ TodoWrite<br>✅ SubAgent<br>✅ Multi Model<br>✅ Chat Management<br>✅ Tools (WebFetch, Bash, TextSearch, FileReadFile, EditFile) | 🔄 Hooks<br>SubAgent (enhanced)<br>✅ Skill<br>✅ Headless Mode<br>✅ Tools (WebSearch)           |
+| Building Open Capabilities      | ✅ Custom Commands                                                                                                                                                                 | ✅ QwenCode SDK<br> Extension                                                                     |
+| Integrating Community Ecosystem |                                                                                                                                                                                    | ✅ VSCode Plugin<br>🔄 ACP/Zed<br>✅ GHA                                                          |
+| Administrative Capabilities     | ✅ Stats<br>✅ Feedback                                                                                                                                                            | Costs<br>Dashboard                                                                                |
+
+> For more details, please see the list below.
+
+## Features
+
+#### Completed Features
+
+| Feature                 | Version   | Description                                             | Category                        |
+| ----------------------- | --------- | ------------------------------------------------------- | ------------------------------- |
+| Skill                   | `V0.6.0`  | Extensible custom AI skills                             | Coding Workflow                 |
+| Github Actions          | `V0.5.0`  | qwen-code-action and automation                         | Integrating Community Ecosystem |
+| VSCode Plugin           | `V0.5.0`  | VSCode extension plugin                                 | Integrating Community Ecosystem |
+| QwenCode SDK            | `V0.4.0`  | Open SDK for third-party integration                    | Building Open Capabilities      |
+| Session                 | `V0.4.0`  | Enhanced session management                             | User Experience                 |
+| i18n                    | `V0.3.0`  | Internationalization and multilingual support           | User Experience                 |
+| Headless Mode           | `V0.3.0`  | Headless mode (non-interactive)                         | Coding Workflow                 |
+| ACP/Zed                 | `V0.2.0`  | ACP and Zed editor integration                          | Integrating Community Ecosystem |
+| Terminal UI             | `V0.1.0+` | Interactive terminal user interface                     | User Experience                 |
+| Settings                | `V0.1.0+` | Configuration management system                         | User Experience                 |
+| Theme                   | `V0.1.0+` | Multi-theme support                                     | User Experience                 |
+| Support OpenAI Protocol | `V0.1.0+` | Support for OpenAI API protocol                         | User Experience                 |
+| Chat Management         | `V0.1.0+` | Session management (save, restore, browse)              | Coding Workflow                 |
+| MCP                     | `V0.1.0+` | Model Context Protocol integration                      | Coding Workflow                 |
+| Multi Model             | `V0.1.0+` | Multi-model support and switching                       | Coding Workflow                 |
+| Slash Commands          | `V0.1.0+` | Slash command system                                    | Coding Workflow                 |
+| Tool: Bash              | `V0.1.0+` | Shell command execution tool (with is_background param) | Coding Workflow                 |
+| Tool: FileRead/EditFile | `V0.1.0+` | File read/write and edit tools                          | Coding Workflow                 |
+| Custom Commands         | `V0.1.0+` | Custom command loading                                  | Building Open Capabilities      |
+| Feedback                | `V0.1.0+` | Feedback mechanism (/bug command)                       | Administrative Capabilities     |
+| Stats                   | `V0.1.0+` | Usage statistics and quota display                      | Administrative Capabilities     |
+| Memory                  | `V0.0.9+` | Project-level and global memory management              | User Experience                 |
+| Cache Control           | `V0.0.9+` | DashScope cache control                                 | User Experience                 |
+| PlanMode                | `V0.0.14` | Task planning mode                                      | Coding Workflow                 |
+| Compress                | `V0.0.11` | Chat compression mechanism                              | User Experience                 |
+| SubAgent                | `V0.0.11` | Dedicated sub-agent system                              | Coding Workflow                 |
+| TodoWrite               | `V0.0.10` | Task management and progress tracking                   | Coding Workflow                 |
+| Tool: TextSearch        | `V0.0.8+` | Text search tool (grep, supports .qwenignore)           | Coding Workflow                 |
+| Tool: WebFetch          | `V0.0.7+` | Web content fetching tool                               | Coding Workflow                 |
+| Tool: WebSearch         | `V0.0.7+` | Web search tool (using Tavily API)                      | Coding Workflow                 |
+| OAuth                   | `V0.0.5+` | OAuth login authentication (Qwen OAuth)                 | User Experience                 |
+
+#### Features to Develop
+
+| Feature                      | Priority | Status      | Description                       | Category                    |
+| ---------------------------- | -------- | ----------- | --------------------------------- | --------------------------- |
+| Better UI                    | P1       | Planned     | Optimized terminal UI interaction | User Experience             |
+| OnBoarding                   | P1       | Planned     | New user onboarding flow          | User Experience             |
+| Permission                   | P1       | Planned     | Permission system optimization    | User Experience             |
+| Cross-platform Compatibility | P1       | In Progress | Windows/Linux/macOS compatibility | User Experience             |
+| LogView                      | P2       | Planned     | Log viewing and debugging feature | User Experience             |
+| Hooks                        | P2       | In Progress | Extension hooks system            | Coding Workflow             |
+| Extension                    | P2       | Planned     | Extension system                  | Building Open Capabilities  |
+| Costs                        | P2       | Planned     | Cost tracking and analysis        | Administrative Capabilities |
+| Dashboard                    | P2       | Planned     | Management dashboard              | Administrative Capabilities |
+
+#### Distinctive Features to Discuss
+
+| Feature          | Status   | Description                                           |
+| ---------------- | -------- | ----------------------------------------------------- |
+| Home Spotlight   | Research | Project discovery and quick launch                    |
+| Competitive Mode | Research | Competitive mode                                      |
+| Pulse            | Research | User activity pulse analysis (OpenAI Pulse reference) |
+| Code Wiki        | Research | Project codebase wiki/documentation system            |