@georgedong32/ccs 7.66.0

package/scripts/code-reviewer.ts

@@ -0,0 +1,217 @@
+#!/usr/bin/env bun
+/**
+ * AI Code Reviewer for CCS CLI
+ *
+ * Fetches PR diff, calls Claude via CLIProxyAPI, posts review as comment.
+ * Runs on self-hosted runner with localhost access to CLIProxyAPI:8317.
+ * Posts as ccs-agy-reviewer[bot] via GitHub App token.
+ *
+ * Usage: bun run scripts/code-reviewer.ts <PR_NUMBER>
+ * Env: CLIPROXY_API_KEY, GITHUB_REPOSITORY, GH_TOKEN
+ */
+
+import { $ } from 'bun';
+
+// Types
+interface PRContext {
+  number: number;
+  title: string;
+  body: string;
+  baseRef: string;
+  headRef: string;
+  files: Array<{ path: string; additions: number; deletions: number }>;
+  diff: string;
+}
+
+// Config
+const MAX_DIFF_LINES = 10000;
+const CLIPROXY_URL = process.env.CLIPROXY_URL || 'http://localhost:8317';
+const MODEL = process.env.REVIEW_MODEL || 'claude-opus-4-6-thinking';
+
+// System prompt for code review - new style
+const CODE_REVIEWER_SYSTEM_PROMPT = `You are the CCS AGY Code Reviewer, an expert AI assistant reviewing pull requests for the CCS CLI project.
+
+## Review Guidelines
+- Focus ONLY on changes in this PR - don't suggest unrelated improvements
+- Be concise - no fluff, no excessive praise
+- Provide specific file:line references for issues
+- Verify claims before making them (check if patterns exist, check actual code)
+- Avoid over-engineering suggestions for simple fixes
+
+## Check For
+1. **Bugs**: Logic errors, edge cases, null handling, race conditions
+2. **Security**: Injection, auth bypass, secrets exposure, data leaks
+3. **Performance**: N+1 queries, missing indexes, inefficient algorithms
+4. **TypeScript**: Proper typing, no \`any\`, null safety
+5. **Consistency**: Similar patterns exist elsewhere that need same fix?
+
+## Output Format
+Structure your response EXACTLY like this (no code fences, render as markdown):
+
+## 🔍 Code Review
+
+**Verdict**: [✅ Approve | ✅ Approve with suggestions | ⚠️ Request changes]
+
+### Summary
+[1-2 sentences on what the PR does and if it's correct]
+
+### ✅ What's Good
+- [Bullet points, 2-4 items max]
+
+### ⚠️ Issues Found
+| File:Line | Issue | Severity |
+|-----------|-------|----------|
+| \`file.ts:123\` | Description | 🔴 High / 🟡 Medium / 🟢 Low |
+
+(If no issues, write "None - LGTM")
+
+### 💡 Suggestions (Optional)
+- [Only if truly valuable, max 2 items]
+
+IMPORTANT: Output ONLY the markdown review. No JSON, no code blocks wrapping the review.`;
+
+// Fetch PR context
+async function getPRContext(prNumber: number, repo: string): Promise<PRContext> {
+  $.throws(true);
+
+  // Get PR metadata
+  const prJson =
+    await $`gh pr view ${prNumber} --repo ${repo} --json number,title,body,baseRefName,headRefName,files`.text();
+  const pr = JSON.parse(prJson);
+
+  // Get diff
+  let diff = await $`gh pr diff ${prNumber} --repo ${repo}`.text();
+
+  // Truncate if too large
+  const lines = diff.split('\n');
+  if (lines.length > MAX_DIFF_LINES) {
+    diff = lines.slice(0, MAX_DIFF_LINES).join('\n') + '\n\n[DIFF TRUNCATED - exceeded 10k lines]';
+  }
+
+  return {
+    number: pr.number,
+    title: pr.title,
+    body: pr.body || '',
+    baseRef: pr.baseRefName,
+    headRef: pr.headRefName,
+    files: pr.files || [],
+    diff,
+  };
+}
+
+// Call Claude via CLIProxyAPI
+async function callClaude(context: PRContext, repo: string): Promise<string> {
+  const apiKey = process.env.CLIPROXY_API_KEY;
+  if (!apiKey) throw new Error('CLIPROXY_API_KEY not set');
+
+  const userMessage = `REPO: ${repo}
+PR NUMBER: ${context.number}
+
+## Pull Request: ${context.title}
+
+### Description
+${context.body || '(No description provided)'}
+
+### Changed Files
+${context.files.map((f) => `- ${f.path} (+${f.additions}/-${f.deletions})`).join('\n')}
+
+### Diff
+\`\`\`diff
+${context.diff}
+\`\`\`
+
+Review this PR following the guidelines. Refer to the project's CLAUDE.md and docs/ folder for conventions.`;
+
+  const response = await fetch(`${CLIPROXY_URL}/v1/messages`, {
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({
+      model: MODEL,
+      max_tokens: 4096,
+      system: CODE_REVIEWER_SYSTEM_PROMPT,
+      messages: [{ role: 'user', content: userMessage }],
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`CLIProxyAPI error: ${response.status} - ${error}`);
+  }
+
+  const data = (await response.json()) as { content: Array<{ text: string }> };
+  const content = data.content[0]?.text;
+
+  if (!content) {
+    throw new Error('Empty response from Claude');
+  }
+
+  return content;
+}
+
+// Post review as PR comment
+async function postReview(prNumber: number, repo: string, reviewContent: string): Promise<void> {
+  // Use gh pr comment to post the review
+  await $`gh pr comment ${prNumber} --repo ${repo} --body ${reviewContent}`;
+}
+
+// Check if already reviewed this PR (avoid spam)
+async function hasRecentReview(prNumber: number, repo: string): Promise<boolean> {
+  try {
+    const comments =
+      await $`gh api repos/${repo}/issues/${prNumber}/comments --jq '[.[] | select(.body | contains("🔍 Code Review"))] | length'`.text();
+    return parseInt(comments.trim(), 10) > 0;
+  } catch {
+    return false;
+  }
+}
+
+// Main
+async function main() {
+  const prNumber = parseInt(process.argv[2], 10);
+  const repo = process.env.GITHUB_REPOSITORY || 'kaitranntt/ccs';
+  const forceReview = process.argv.includes('--force');
+
+  if (!prNumber || isNaN(prNumber)) {
+    console.error('Usage: bun run scripts/code-reviewer.ts <PR_NUMBER> [--force]');
+    process.exit(1);
+  }
+
+  console.log(`[i] Reviewing PR #${prNumber} in ${repo}`);
+
+  try {
+    // Check for existing review (avoid spam)
+    if (!forceReview && (await hasRecentReview(prNumber, repo))) {
+      console.log('[i] Already reviewed this PR. Use --force to review again.');
+      process.exit(0);
+    }
+
+    // 1. Get PR context
+    console.log('[i] Fetching PR context...');
+    const context = await getPRContext(prNumber, repo);
+    console.log(`[i] PR: "${context.title}" (${context.files.length} files changed)`);
+
+    const diffLines = context.diff.split('\n').length;
+    if (diffLines > MAX_DIFF_LINES) {
+      console.log(`[!] Diff too large (${diffLines} lines), truncated to ${MAX_DIFF_LINES}`);
+    }
+
+    // 2. Call Claude
+    console.log(`[i] Calling Claude (${MODEL}) for review...`);
+    const reviewContent = await callClaude(context, repo);
+    console.log('[i] Review generated');
+
+    // 3. Post review as comment
+    console.log('[i] Posting review to PR...');
+    await postReview(prNumber, repo, reviewContent);
+    console.log('[OK] Review posted successfully');
+  } catch (error) {
+    console.error('[X] Review failed:', error);
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/completion/README.md

@@ -0,0 +1,232 @@
+# Shell Completion for CCS
+
+Tab completion for CCS commands, subcommands, profiles, and flags.
+
+The completion scripts are thin adapters over the hidden `ccs __complete` backend so
+all supported shells stay aligned with the same command graph.
+
+**Supported Shells:** Bash, Zsh, Fish, PowerShell
+
+## Features
+
+- Complete profile names (both settings-based and account-based)
+- Complete root commands, help topics, provider shortcuts, and command flags
+- Complete `ccs auth` and `ccs api` lifecycle subcommands
+- Context-aware: suggests relevant options based on current command
+
+## Quick Install (Recommended)
+
+```bash
+ccs --shell-completion
+```
+
+This will:
+- Auto-detect your shell
+- Copy completion files to `~/.ccs/completions/`
+- Configure your shell profile with proper comment markers
+- Show instructions to activate
+
+**Manual shell selection:**
+```bash
+ccs --shell-completion --bash        # Force bash
+ccs --shell-completion --zsh         # Force zsh
+ccs --shell-completion --fish        # Force fish
+ccs --shell-completion --powershell  # Force PowerShell
+```
+
+**Help and verification:**
+```bash
+ccs help completion
+ccs --shell-completion --force
+```
+
+## Manual Installation
+
+Completion files are installed to `~/.ccs/completions/` during `npm install`.
+
+### Bash
+
+Add to `~/.bashrc` or `~/.bash_profile`:
+
+```bash
+# CCS shell completion
+source ~/.ccs/completions/ccs.bash
+```
+
+Then reload:
+```bash
+source ~/.bashrc
+```
+
+### Zsh
+
+1. Create completion directory:
+   ```zsh
+   mkdir -p ~/.zsh/completion
+   ```
+
+2. Copy completion file:
+   ```zsh
+   cp ~/.ccs/completions/ccs.zsh ~/.zsh/completion/_ccs
+   ```
+
+3. Add to `~/.zshrc`:
+   ```zsh
+   # CCS shell completion
+   fpath=(~/.zsh/completion $fpath)
+   autoload -Uz compinit && compinit
+   ```
+
+4. Reload:
+   ```zsh
+   source ~/.zshrc
+   ```
+
+### PowerShell
+
+Add to your PowerShell profile (`$PROFILE`):
+
+```powershell
+# CCS shell completion
+. "$HOME\.ccs\completions\ccs.ps1"
+```
+
+Then reload:
+```powershell
+. $PROFILE
+```
+
+### Fish
+
+**User installation (recommended)**
+
+Fish automatically loads completions from `~/.config/fish/completions/`:
+
+```fish
+# Create completion directory if it doesn't exist
+mkdir -p ~/.config/fish/completions
+
+# Copy completion script
+cp scripts/completion/ccs.fish ~/.config/fish/completions/
+```
+
+That's it! Fish will automatically load the completion on demand. No need to source or reload.
+
+**System-wide installation (requires sudo)**
+
+```fish
+sudo cp scripts/completion/ccs.fish /usr/share/fish/vendor_completions.d/
+```
+
+## Usage Examples
+
+### Basic Completion
+
+```bash
+$ ccs <TAB>
+auth      api       cliproxy  config    doctor    docker    help
+
+$ ccs help <TAB>
+profiles  providers  completion  targets
+```
+
+### Context Completion
+
+```bash
+$ ccs auth show <TAB>
+work      personal  team      --json
+
+$ ccs api <TAB>
+create    list      discover  copy    export  import  remove
+```
+
+### Backend Contract
+
+```bash
+$ ccs __complete --shell bash --current do
+doctor
+docker
+```
+
+Shell adapters now call the shared CCS completion backend instead of maintaining their own
+copy of the command graph. That means:
+- top-level commands, help topics, and provider shortcuts come from CCS itself
+- dynamic profiles and CLIProxy variants resolve through the real config loaders
+- bash, zsh, fish, and PowerShell stay aligned with the same completion logic
+
+## Troubleshooting
+
+### Bash
+
+1. Check if completion is loaded:
+   ```bash
+   complete -p ccs
+   ```
+2. Verify the backend directly:
+   ```bash
+   ccs __complete --shell bash --current "" -- help
+   ```
+
+### Zsh
+
+1. Verify completion system is enabled:
+   ```zsh
+   autoload -Uz compinit && compinit
+   ```
+2. Rebuild the cache if needed:
+   ```zsh
+   rm ~/.zcompdump && compinit
+   ```
+3. Verify the backend directly:
+   ```zsh
+   ccs __complete --shell zsh --current "" -- help
+   ```
+
+### PowerShell
+
+1. Check that the profile exists:
+   ```powershell
+   Test-Path $PROFILE
+   ```
+2. Verify the backend directly:
+   ```powershell
+   ccs __complete --shell powershell --current "" -- help
+   ```
+
+### Fish
+
+1. Verify completion file location:
+   ```fish
+   ls ~/.config/fish/completions/ccs.fish
+   ```
+2. Test completion manually:
+   ```fish
+   complete -C'ccs '
+   ```
+3. Verify the backend directly:
+   ```fish
+   ccs __complete --shell fish --current "" -- help
+   ```
+
+## Technical Details
+
+- Bash uses `complete -F`
+- Zsh uses a custom `_ccs` completion function
+- Fish uses `complete -a` with backend command substitution
+- PowerShell uses `Register-ArgumentCompleter`
+- All four shells now delegate suggestion logic to `ccs __complete`
+
+## Contributing
+
+When adding or changing command surfaces:
+1. Update the shared TypeScript command/completion catalog
+2. Run `bun run validate`
+3. Smoke-check at least one installed shell adapter plus the backend directly
+
+## See Also
+
+- [CCS Documentation](https://github.com/kaitranntt/ccs)
+- [Bash Programmable Completion](https://www.gnu.org/software/bash/manual/html_node/Programmable-Completion.html)
+- [Zsh Completion System](http://zsh.sourceforge.net/Doc/Release/Completion-System.html)
+- [Fish Completion Tutorial](https://fishshell.com/docs/current/completions.html)
+- [PowerShell Argument Completers](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/register-argumentcompleter)

package/scripts/completion/ccs.bash

@@ -0,0 +1,42 @@
+# Bash completion for CCS (Claude Code Switch)
+# Compatible with bash 3.2+
+
+_ccs_completion() {
+  local cur
+  COMPREPLY=()
+  cur="${COMP_WORDS[COMP_CWORD]}"
+
+  local tokens_before_current=()
+  if [[ ${COMP_CWORD} -gt 1 ]]; then
+    tokens_before_current=("${COMP_WORDS[@]:1:COMP_CWORD-1}")
+  fi
+
+  while IFS= read -r line; do
+    [[ -n "${line}" ]] && COMPREPLY+=("${line}")
+  done < <(__ccs_completion_run "${cur}" "${tokens_before_current[@]}")
+
+  return 0
+}
+
+__ccs_completion_run() {
+  local current="$1"
+  shift || true
+
+  local script_dir repo_root repo_cli
+  script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  repo_root="$(cd "${script_dir}/../.." && pwd)"
+  repo_cli="${repo_root}/dist/ccs.js"
+  if [[ ! -f "${repo_cli}" ]]; then
+    repo_cli="${repo_root}/bin/ccs.js"
+  fi
+  if [[ -f "${repo_cli}" ]]; then
+    node "${repo_cli}" __complete --shell bash --current "${current}" -- "$@" 2>/dev/null
+    return 0
+  fi
+
+  if command -v ccs >/dev/null 2>&1; then
+    ccs __complete --shell bash --current "${current}" -- "$@" 2>/dev/null
+  fi
+}
+
+complete -F _ccs_completion ccs

package/scripts/completion/ccs.fish

@@ -0,0 +1,30 @@
+# Fish completion for CCS (Claude Code Switch)
+
+function __fish_ccs_complete
+    set -l tokens_before_current (commandline -opc)
+    if test (count $tokens_before_current) -gt 0
+        set -e tokens_before_current[1]
+    end
+
+    set -l current (commandline -ct)
+    if test -n "$current"; and test (count $tokens_before_current) -gt 0; and test "$tokens_before_current[-1]" = "$current"
+        set -e tokens_before_current[-1]
+    end
+
+    set -l script_file (status filename)
+    set -l repo_root (realpath (dirname $script_file)/../.. 2>/dev/null)
+    set -l repo_cli "$repo_root/dist/ccs.js"
+    if not test -f "$repo_cli"
+        set repo_cli "$repo_root/bin/ccs.js"
+    end
+    if test -f "$repo_cli"
+        node "$repo_cli" __complete --shell fish --current "$current" -- $tokens_before_current 2>/dev/null
+        return
+    end
+
+    if command -sq ccs
+        ccs __complete --shell fish --current "$current" -- $tokens_before_current 2>/dev/null
+    end
+end
+
+complete -c ccs -f -a "(__fish_ccs_complete)"

package/scripts/completion/ccs.ps1

@@ -0,0 +1,56 @@
+# PowerShell completion for CCS (Claude Code Switch)
+
+function Invoke-CcsCompletionBackend {
+    param(
+        [string]$CurrentWord,
+        [string[]]$TokensBeforeCurrent
+    )
+
+    $repoRoot = (Resolve-Path (Join-Path $PSScriptRoot '..\..')).Path
+    $repoCli = Join-Path $repoRoot 'dist\ccs.js'
+    if (-not (Test-Path $repoCli)) {
+        $repoCli = Join-Path $repoRoot 'bin\ccs.js'
+    }
+    if (Test-Path $repoCli) {
+        & node $repoCli __complete --shell powershell --current $CurrentWord -- @TokensBeforeCurrent 2>$null
+        return
+    }
+
+    if (Get-Command ccs -ErrorAction SilentlyContinue) {
+        & ccs __complete --shell powershell --current $CurrentWord -- @TokensBeforeCurrent 2>$null
+    }
+}
+
+Register-ArgumentCompleter -CommandName ccs -ScriptBlock {
+    param($commandName, $wordToComplete, $commandAst, $fakeBoundParameters)
+
+    $commandElements = @($commandAst.CommandElements | ForEach-Object { $_.Extent.Text })
+    $tokensBeforeCurrent = @()
+    if ($commandElements.Count -gt 1) {
+        $tokensBeforeCurrent = $commandElements[1..($commandElements.Count - 1)]
+        if ($tokensBeforeCurrent.Count -gt 0 -and $tokensBeforeCurrent[-1] -eq $wordToComplete) {
+            $tokensBeforeCurrent = if ($tokensBeforeCurrent.Count -gt 1) {
+                $tokensBeforeCurrent[0..($tokensBeforeCurrent.Count - 2)]
+            } else {
+                @()
+            }
+        }
+    }
+
+    foreach ($line in Invoke-CcsCompletionBackend -CurrentWord $wordToComplete -TokensBeforeCurrent $tokensBeforeCurrent) {
+        if ([string]::IsNullOrWhiteSpace($line)) {
+            continue
+        }
+
+        $parts = $line -split "`t", 2
+        $value = $parts[0]
+        $description = if ($parts.Count -gt 1) { $parts[1] } else { $parts[0] }
+
+        [System.Management.Automation.CompletionResult]::new(
+            $value,
+            $value,
+            'ParameterValue',
+            $description
+        )
+    }
+}

package/scripts/completion/ccs.zsh

@@ -0,0 +1,41 @@
+#compdef ccs
+
+# Zsh completion for CCS (Claude Code Switch)
+
+_ccs() {
+  local current
+  current="${words[CURRENT]}"
+
+  local -a tokens_before_current
+  if (( CURRENT > 2 )); then
+    tokens_before_current=("${words[@]:2:$((CURRENT-2))}")
+  else
+    tokens_before_current=()
+  fi
+
+  local -a suggestions
+  suggestions=("${(@f)$(__ccs_completion_run "${current}" "${tokens_before_current[@]}")}")
+  compadd -- "${suggestions[@]}"
+}
+
+__ccs_completion_run() {
+  local current="$1"
+  shift || true
+
+  local script_path script_dir repo_root repo_cli
+  script_path="${(%):-%N}"
+  script_dir="${script_path:A:h}"
+  repo_root="${script_dir:h:h}"
+  repo_cli="${repo_root}/dist/ccs.js"
+  if [[ ! -f "${repo_cli}" ]]; then
+    repo_cli="${repo_root}/bin/ccs.js"
+  fi
+  if [[ -f "${repo_cli}" ]]; then
+    node "${repo_cli}" __complete --shell zsh --current "${current}" -- "$@" 2>/dev/null
+    return 0
+  fi
+
+  if (( $+commands[ccs] )); then
+    ccs __complete --shell zsh --current "${current}" -- "$@" 2>/dev/null
+  fi
+}