@kaitranntt/ccs 3.5.0 → 4.1.0

package/bin/delegation/settings-parser.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parses Claude Code settings for tool restrictions
+ */
+class SettingsParser {
+  /**
+   * Parse default permission mode from project settings
+   * @param {string} projectDir - Project directory (usually cwd)
+   * @returns {string} Default permission mode (e.g., 'acceptEdits', 'bypassPermissions', 'plan', 'default')
+   */
+  static parseDefaultPermissionMode(projectDir) {
+    const settings = this._loadSettings(projectDir);
+    const permissions = settings.permissions || {};
+
+    // Priority: local > shared > fallback to 'acceptEdits'
+    const defaultMode = permissions.defaultMode || 'acceptEdits';
+
+    if (process.env.CCS_DEBUG) {
+      console.error(`[i] Permission mode from settings: ${defaultMode}`);
+    }
+
+    return defaultMode;
+  }
+
+  /**
+   * Parse project settings for tool restrictions
+   * @param {string} projectDir - Project directory (usually cwd)
+   * @returns {Object} { allowedTools: string[], disallowedTools: string[] }
+   */
+  static parseToolRestrictions(projectDir) {
+    const settings = this._loadSettings(projectDir);
+    const permissions = settings.permissions || {};
+
+    const allowed = permissions.allow || [];
+    const denied = permissions.deny || [];
+
+    if (process.env.CCS_DEBUG) {
+      console.error(`[i] Tool restrictions: ${allowed.length} allowed, ${denied.length} denied`);
+    }
+
+    return {
+      allowedTools: allowed,
+      disallowedTools: denied
+    };
+  }
+
+  /**
+   * Load and merge settings files (local overrides shared)
+   * @param {string} projectDir - Project directory
+   * @returns {Object} Merged settings
+   * @private
+   */
+  static _loadSettings(projectDir) {
+    const claudeDir = path.join(projectDir, '.claude');
+    const sharedPath = path.join(claudeDir, 'settings.json');
+    const localPath = path.join(claudeDir, 'settings.local.json');
+
+    // Load shared settings
+    const shared = this._readJsonSafe(sharedPath) || {};
+
+    // Load local settings (overrides shared)
+    const local = this._readJsonSafe(localPath) || {};
+
+    // Merge permissions (local overrides shared)
+    return {
+      permissions: {
+        allow: [
+          ...(shared.permissions?.allow || []),
+          ...(local.permissions?.allow || [])
+        ],
+        deny: [
+          ...(shared.permissions?.deny || []),
+          ...(local.permissions?.deny || [])
+        ],
+        // Local defaultMode takes priority over shared
+        defaultMode: local.permissions?.defaultMode || shared.permissions?.defaultMode || null
+      }
+    };
+  }
+
+  /**
+   * Read JSON file safely (no throw)
+   * @param {string} filePath - Path to JSON file
+   * @returns {Object|null} Parsed JSON or null
+   * @private
+   */
+  static _readJsonSafe(filePath) {
+    try {
+      if (!fs.existsSync(filePath)) {
+        return null;
+      }
+
+      const content = fs.readFileSync(filePath, 'utf8');
+      return JSON.parse(content);
+    } catch (error) {
+      if (process.env.CCS_DEBUG) {
+        console.warn(`[!] Failed to read settings: ${filePath}: ${error.message}`);
+      }
+      return null;
+    }
+  }
+}
+
+module.exports = { SettingsParser };

package/bin/management/doctor.js

@@ -61,7 +61,9 @@ class Doctor {
     this.checkClaudeSettings();
     this.checkProfiles();
     this.checkInstances();
+    this.checkDelegation();
     this.checkPermissions();
+    this.checkCcsSymlinks();
 
     this.showReport();
     return this.results;
@@ -269,7 +271,64 @@ class Doctor {
   }
 
   /**
-   * Check 7: File permissions
+   * Check 7: Delegation system
+   */
+  checkDelegation() {
+    process.stdout.write('[?] Checking delegation... ');
+
+    // Check if delegation-rules.json exists
+    const delegationRulesPath = path.join(this.ccsDir, 'delegation-rules.json');
+    const hasDelegationRules = fs.existsSync(delegationRulesPath);
+
+    // Check if delegation commands exist
+    const sharedCommandsDir = path.join(this.ccsDir, 'shared', 'commands', 'ccs');
+    const hasGlmCommand = fs.existsSync(path.join(sharedCommandsDir, 'glm.md'));
+    const hasKimiCommand = fs.existsSync(path.join(sharedCommandsDir, 'kimi.md'));
+    const hasCreateCommand = fs.existsSync(path.join(sharedCommandsDir, 'create.md'));
+
+    if (!hasGlmCommand || !hasKimiCommand || !hasCreateCommand) {
+      console.log(colored('[!]', 'yellow'), '(not installed)');
+      this.results.addCheck(
+        'Delegation',
+        'warning',
+        'Delegation commands not found',
+        'Install with: npm install -g @kaitranntt/ccs --force'
+      );
+      return;
+    }
+
+    // Check profile validity using DelegationValidator
+    const { DelegationValidator } = require('../utils/delegation-validator');
+    const readyProfiles = [];
+
+    for (const profile of ['glm', 'kimi']) {
+      const validation = DelegationValidator.validate(profile);
+      if (validation.valid) {
+        readyProfiles.push(profile);
+      }
+    }
+
+    if (readyProfiles.length === 0) {
+      console.log(colored('[!]', 'yellow'), '(no profiles ready)');
+      this.results.addCheck(
+        'Delegation',
+        'warning',
+        'Delegation installed but no profiles configured',
+        'Configure profiles with valid API keys (not placeholders)'
+      );
+      return;
+    }
+
+    console.log(colored('[OK]', 'green'), `(${readyProfiles.join(', ')} ready)`);
+    this.results.addCheck(
+      'Delegation',
+      'success',
+      `${readyProfiles.length} profile(s) ready: ${readyProfiles.join(', ')}`
+    );
+  }
+
+  /**
+   * Check 8: File permissions
    */
   checkPermissions() {
     process.stdout.write('[?] Checking permissions... ');
@@ -292,6 +351,40 @@ class Doctor {
     }
   }
 
+  /**
+   * Check 9: CCS symlinks to ~/.claude/
+   */
+  checkCcsSymlinks() {
+    process.stdout.write('[?] Checking CCS symlinks... ');
+
+    try {
+      const ClaudeSymlinkManager = require('../utils/claude-symlink-manager');
+      const manager = new ClaudeSymlinkManager();
+      const health = manager.checkHealth();
+
+      if (health.healthy) {
+        console.log(colored('[OK]', 'green'));
+        this.results.addCheck('CCS Symlinks', 'success', 'All CCS items properly symlinked');
+      } else {
+        console.log(colored('[!]', 'yellow'));
+        this.results.addCheck(
+          'CCS Symlinks',
+          'warning',
+          health.issues.join(', '),
+          'Run: ccs update'
+        );
+      }
+    } catch (e) {
+      console.log(colored('[!]', 'yellow'));
+      this.results.addCheck(
+        'CCS Symlinks',
+        'warning',
+        'Could not check CCS symlinks: ' + e.message,
+        'Run: ccs update'
+      );
+    }
+  }
+
   /**
    * Show health check report
    */

package/bin/utils/claude-symlink-manager.js

@@ -0,0 +1,238 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * ClaudeSymlinkManager - Manages selective symlinks from ~/.ccs/.claude/ to ~/.claude/
+ * v4.1.0: Selective symlinking for CCS items
+ *
+ * Purpose: Ship CCS items (.claude/) with package and symlink them to user's ~/.claude/
+ * Architecture:
+ *   - ~/.ccs/.claude/* (source, ships with CCS)
+ *   - ~/.claude/* (target, gets selective symlinks)
+ *   - ~/.ccs/shared/ (UNTOUCHED, existing profile mechanism)
+ *
+ * Symlink Chain:
+ *   profile -> ~/.ccs/shared/ -> ~/.claude/ (which has symlinks to ~/.ccs/.claude/)
+ */
+class ClaudeSymlinkManager {
+  constructor() {
+    this.homeDir = os.homedir();
+    this.ccsClaudeDir = path.join(this.homeDir, '.ccs', '.claude');
+    this.userClaudeDir = path.join(this.homeDir, '.claude');
+
+    // CCS items to symlink (selective, item-level)
+    this.ccsItems = [
+      { source: 'commands/ccs', target: 'commands/ccs', type: 'directory' },
+      { source: 'skills/ccs-delegation', target: 'skills/ccs-delegation', type: 'directory' },
+      { source: 'agents/ccs-delegator.md', target: 'agents/ccs-delegator.md', type: 'file' }
+    ];
+  }
+
+  /**
+   * Install CCS items to user's ~/.claude/ via selective symlinks
+   * Safe: backs up existing files before creating symlinks
+   */
+  install() {
+    // Ensure ~/.ccs/.claude/ exists (should be shipped with package)
+    if (!fs.existsSync(this.ccsClaudeDir)) {
+      console.log('[!] CCS .claude/ directory not found, skipping symlink installation');
+      return;
+    }
+
+    // Create ~/.claude/ if missing
+    if (!fs.existsSync(this.userClaudeDir)) {
+      console.log('[i] Creating ~/.claude/ directory');
+      fs.mkdirSync(this.userClaudeDir, { recursive: true, mode: 0o700 });
+    }
+
+    // Install each CCS item
+    for (const item of this.ccsItems) {
+      this._installItem(item);
+    }
+
+    console.log('[OK] CCS items installed to ~/.claude/');
+  }
+
+  /**
+   * Install a single CCS item with conflict handling
+   * @param {Object} item - Item descriptor {source, target, type}
+   * @private
+   */
+  _installItem(item) {
+    const sourcePath = path.join(this.ccsClaudeDir, item.source);
+    const targetPath = path.join(this.userClaudeDir, item.target);
+    const targetDir = path.dirname(targetPath);
+
+    // Ensure source exists
+    if (!fs.existsSync(sourcePath)) {
+      console.log(`[!] Source not found: ${item.source}, skipping`);
+      return;
+    }
+
+    // Create target parent directory if needed
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true, mode: 0o700 });
+    }
+
+    // Check if target already exists
+    if (fs.existsSync(targetPath)) {
+      // Check if it's already the correct symlink
+      if (this._isOurSymlink(targetPath, sourcePath)) {
+        return; // Already correct, skip
+      }
+
+      // Backup existing file/directory
+      this._backupItem(targetPath);
+    }
+
+    // Create symlink
+    try {
+      const symlinkType = item.type === 'directory' ? 'dir' : 'file';
+      fs.symlinkSync(sourcePath, targetPath, symlinkType);
+      console.log(`[OK] Symlinked ${item.target}`);
+    } catch (err) {
+      // Windows fallback: stub for now, full implementation in v4.2
+      if (process.platform === 'win32') {
+        console.log(`[!] Symlink failed for ${item.target} (Windows fallback deferred to v4.2)`);
+        console.log(`[i] Enable Developer Mode or wait for next update`);
+      } else {
+        console.log(`[!] Failed to symlink ${item.target}: ${err.message}`);
+      }
+    }
+  }
+
+  /**
+   * Check if target is already the correct symlink pointing to source
+   * @param {string} targetPath - Target path to check
+   * @param {string} expectedSource - Expected source path
+   * @returns {boolean} True if target is correct symlink
+   * @private
+   */
+  _isOurSymlink(targetPath, expectedSource) {
+    try {
+      const stats = fs.lstatSync(targetPath);
+
+      if (!stats.isSymbolicLink()) {
+        return false;
+      }
+
+      const actualTarget = fs.readlinkSync(targetPath);
+      const resolvedTarget = path.resolve(path.dirname(targetPath), actualTarget);
+
+      return resolvedTarget === expectedSource;
+    } catch (err) {
+      return false;
+    }
+  }
+
+  /**
+   * Backup existing item before replacing with symlink
+   * @param {string} itemPath - Path to item to backup
+   * @private
+   */
+  _backupItem(itemPath) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
+    const backupPath = `${itemPath}.backup-${timestamp}`;
+
+    try {
+      // If backup already exists, use counter
+      let finalBackupPath = backupPath;
+      let counter = 1;
+      while (fs.existsSync(finalBackupPath)) {
+        finalBackupPath = `${backupPath}-${counter}`;
+        counter++;
+      }
+
+      fs.renameSync(itemPath, finalBackupPath);
+      console.log(`[i] Backed up existing item to ${path.basename(finalBackupPath)}`);
+    } catch (err) {
+      console.log(`[!] Failed to backup ${itemPath}: ${err.message}`);
+      throw err; // Don't proceed if backup fails
+    }
+  }
+
+  /**
+   * Uninstall CCS items from ~/.claude/ (remove symlinks only)
+   * Safe: only removes items that are CCS symlinks
+   */
+  uninstall() {
+    let removed = 0;
+
+    for (const item of this.ccsItems) {
+      const targetPath = path.join(this.userClaudeDir, item.target);
+      const sourcePath = path.join(this.ccsClaudeDir, item.source);
+
+      // Only remove if it's our symlink
+      if (fs.existsSync(targetPath) && this._isOurSymlink(targetPath, sourcePath)) {
+        try {
+          fs.unlinkSync(targetPath);
+          console.log(`[OK] Removed ${item.target}`);
+          removed++;
+        } catch (err) {
+          console.log(`[!] Failed to remove ${item.target}: ${err.message}`);
+        }
+      }
+    }
+
+    if (removed > 0) {
+      console.log(`[OK] Removed ${removed} CCS items from ~/.claude/`);
+    } else {
+      console.log('[i] No CCS items to remove');
+    }
+  }
+
+  /**
+   * Check symlink health and report issues
+   * Used by 'ccs doctor' command
+   * @returns {Object} Health check results {healthy: boolean, issues: string[]}
+   */
+  checkHealth() {
+    const issues = [];
+    let healthy = true;
+
+    // Check if ~/.ccs/.claude/ exists
+    if (!fs.existsSync(this.ccsClaudeDir)) {
+      issues.push('CCS .claude/ directory missing (reinstall CCS)');
+      healthy = false;
+      return { healthy, issues };
+    }
+
+    // Check each item
+    for (const item of this.ccsItems) {
+      const sourcePath = path.join(this.ccsClaudeDir, item.source);
+      const targetPath = path.join(this.userClaudeDir, item.target);
+
+      // Check source exists
+      if (!fs.existsSync(sourcePath)) {
+        issues.push(`Source missing: ${item.source}`);
+        healthy = false;
+        continue;
+      }
+
+      // Check target
+      if (!fs.existsSync(targetPath)) {
+        issues.push(`Not installed: ${item.target} (run 'ccs update' to install)`);
+        healthy = false;
+      } else if (!this._isOurSymlink(targetPath, sourcePath)) {
+        issues.push(`Not a CCS symlink: ${item.target} (run 'ccs update' to fix)`);
+        healthy = false;
+      }
+    }
+
+    return { healthy, issues };
+  }
+
+  /**
+   * Re-install symlinks (used by 'ccs update' command)
+   * Same as install() but with explicit re-installation message
+   */
+  update() {
+    console.log('[i] Updating CCS items in ~/.claude/...');
+    this.install();
+  }
+}
+
+module.exports = ClaudeSymlinkManager;

package/bin/utils/delegation-validator.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Validates delegation profiles for CCS delegation system
+ * Ensures profiles exist and have valid API keys configured
+ */
+class DelegationValidator {
+  /**
+   * Validate a delegation profile
+   * @param {string} profileName - Name of profile to validate (e.g., 'glm', 'kimi')
+   * @returns {Object} Validation result { valid: boolean, error?: string, settingsPath?: string }
+   */
+  static validate(profileName) {
+    const homeDir = os.homedir();
+    const settingsPath = path.join(homeDir, '.ccs', `${profileName}.settings.json`);
+
+    // Check if profile directory exists
+    if (!fs.existsSync(settingsPath)) {
+      return {
+        valid: false,
+        error: `Profile not found: ${profileName}`,
+        suggestion: `Profile settings missing at: ${settingsPath}\n\n` +
+                   `To set up ${profileName} profile:\n` +
+                   `  1. Copy base settings: cp config/base-${profileName}.settings.json ~/.ccs/${profileName}.settings.json\n` +
+                   `  2. Edit settings: Edit ~/.ccs/${profileName}.settings.json\n` +
+                   `  3. Set your API key in ANTHROPIC_AUTH_TOKEN field`
+      };
+    }
+
+    // Read and parse settings.json
+    let settings;
+    try {
+      const settingsContent = fs.readFileSync(settingsPath, 'utf8');
+      settings = JSON.parse(settingsContent);
+    } catch (error) {
+      return {
+        valid: false,
+        error: `Failed to parse settings.json for ${profileName}`,
+        suggestion: `Settings file is corrupted or invalid JSON.\n\n` +
+                   `Location: ${settingsPath}\n` +
+                   `Parse error: ${error.message}\n\n` +
+                   `Fix: Restore from base config:\n` +
+                   `  cp config/base-${profileName}.settings.json ~/.ccs/${profileName}.settings.json`
+      };
+    }
+
+    // Validate API key exists and is not default
+    const apiKey = settings.env?.ANTHROPIC_AUTH_TOKEN;
+
+    if (!apiKey) {
+      return {
+        valid: false,
+        error: `API key not configured for ${profileName}`,
+        suggestion: `Missing ANTHROPIC_AUTH_TOKEN in settings.\n\n` +
+                   `Edit: ${settingsPath}\n` +
+                   `Set: env.ANTHROPIC_AUTH_TOKEN to your API key`
+      };
+    }
+
+    // Check for default placeholder values
+    const defaultPlaceholders = [
+      'YOUR_GLM_API_KEY_HERE',
+      'YOUR_KIMI_API_KEY_HERE',
+      'YOUR_API_KEY_HERE',
+      'your-api-key-here',
+      'PLACEHOLDER'
+    ];
+
+    if (defaultPlaceholders.some(placeholder => apiKey.includes(placeholder))) {
+      return {
+        valid: false,
+        error: `Default API key placeholder detected for ${profileName}`,
+        suggestion: `API key is still set to default placeholder.\n\n` +
+                   `To configure your profile:\n` +
+                   `  1. Edit: ${settingsPath}\n` +
+                   `  2. Replace ANTHROPIC_AUTH_TOKEN with your actual API key\n\n` +
+                   `Get API key:\n` +
+                   `  GLM: https://z.ai/manage-apikey/apikey-list\n` +
+                   `  Kimi: https://platform.moonshot.cn/console/api-keys`
+      };
+    }
+
+    // Validation passed
+    return {
+      valid: true,
+      settingsPath,
+      apiKey: apiKey.substring(0, 8) + '...' // Show first 8 chars for verification
+    };
+  }
+
+  /**
+   * Format validation error for display
+   * @param {Object} result - Validation result from validate()
+   * @returns {string} Formatted error message
+   */
+  static formatError(result) {
+    if (result.valid) {
+      return '';
+    }
+
+    let message = `\n[X] ${result.error}\n\n`;
+
+    if (result.suggestion) {
+      message += `${result.suggestion}\n`;
+    }
+
+    return message;
+  }
+
+  /**
+   * Check if profile is delegation-ready (shorthand)
+   * @param {string} profileName - Profile to check
+   * @returns {boolean} True if ready for delegation
+   */
+  static isReady(profileName) {
+    const result = this.validate(profileName);
+    return result.valid;
+  }
+
+  /**
+   * Get all delegation-ready profiles
+   * @returns {Array<string>} List of profile names ready for delegation
+   */
+  static getReadyProfiles() {
+    const homeDir = os.homedir();
+    const ccsDir = path.join(homeDir, '.ccs');
+
+    if (!fs.existsSync(ccsDir)) {
+      return [];
+    }
+
+    const profiles = [];
+    const entries = fs.readdirSync(ccsDir, { withFileTypes: true });
+
+    // Look for *.settings.json files
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith('.settings.json')) {
+        const profileName = entry.name.replace('.settings.json', '');
+        if (this.isReady(profileName)) {
+          profiles.push(profileName);
+        }
+      }
+    }
+
+    return profiles;
+  }
+}
+
+module.exports = { DelegationValidator };

package/lib/ccs

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 # Version (updated by scripts/bump-version.sh)
-CCS_VERSION="3.5.0"
+CCS_VERSION="4.1.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 readonly CONFIG_FILE="${CCS_CONFIG:-$HOME/.ccs/config.json}"
 readonly PROFILES_JSON="$HOME/.ccs/profiles.json"
@@ -187,6 +187,13 @@ show_help() {
   echo -e "  ${YELLOW}ccs work${RESET}                    Switch to work account"
   echo -e "  ${YELLOW}ccs personal${RESET}                Switch to personal account"
   echo ""
+  echo -e "${CYAN}Delegation (Token Optimization):${RESET}"
+  echo -e "  ${YELLOW}/ccs:glm \"task\"${RESET}             Delegate to GLM-4.6 within Claude session"
+  echo -e "  ${YELLOW}/ccs:kimi \"task\"${RESET}            Delegate to Kimi for long context"
+  echo -e "  ${YELLOW}/ccs:create m2${RESET}              Create custom delegation command"
+  echo -e "  Use delegation to save tokens on simple tasks"
+  echo -e "  Commands work inside Claude Code sessions only"
+  echo ""
   echo -e "${CYAN}Diagnostics:${RESET}"
   echo -e "  ${YELLOW}ccs doctor${RESET}                  Run health check and diagnostics"
   echo ""
@@ -522,6 +529,33 @@ show_version() {
   # Simple config display
   local config="${CCS_CONFIG:-$HOME/.ccs/config.json}"
   echo -e "  ${CYAN}Config:${RESET} ${config}"
+
+  # Delegation status
+  local delegation_rules="$HOME/.ccs/delegation-rules.json"
+  if [[ -f "$delegation_rules" ]]; then
+    echo -e "  ${CYAN}Delegation:${RESET} Enabled"
+
+    # Check which profiles are delegation-ready
+    local ready_profiles=()
+    for profile in glm kimi; do
+      local settings_file="$HOME/.ccs/profiles/$profile/settings.json"
+      if [[ -f "$settings_file" ]]; then
+        # Check if API key is configured (not a placeholder)
+        local api_key=$(jq -r '.env.ANTHROPIC_AUTH_TOKEN // empty' "$settings_file" 2>/dev/null)
+        if [[ -n "$api_key" ]] && [[ ! "$api_key" =~ YOUR_.*_API_KEY_HERE ]]; then
+          ready_profiles+=("$profile")
+        fi
+      fi
+    done
+
+    if [[ ${#ready_profiles[@]} -gt 0 ]]; then
+      echo -e "  ${CYAN}Ready:${RESET} ${ready_profiles[*]}"
+    else
+      echo -e "  ${CYAN}Ready:${RESET} None (configure profiles first)"
+    fi
+  else
+    echo -e "  ${CYAN}Delegation:${RESET} Not configured"
+  fi
   echo ""
 
   echo -e "${CYAN}Documentation:${RESET} https://github.com/kaitranntt/ccs"

package/lib/ccs.ps1

@@ -12,7 +12,7 @@ param(
 $ErrorActionPreference = "Stop"
 
 # Version (updated by scripts/bump-version.sh)
-$CcsVersion = "3.5.0"
+$CcsVersion = "4.1.0"
 $ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
 $ConfigFile = if ($env:CCS_CONFIG) { $env:CCS_CONFIG } else { "$env:USERPROFILE\.ccs\config.json" }
 $ProfilesJson = "$env:USERPROFILE\.ccs\profiles.json"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaitranntt/ccs",
-  "version": "3.5.0",
+  "version": "4.1.0",
   "description": "Claude Code Switch - Instant profile switching between Claude Sonnet 4.5 and GLM 4.6",
   "keywords": [
     "cli",
@@ -31,6 +31,7 @@
     "lib/",
     "scripts/",
     "config/",
+    ".claude/",
     "VERSION",
     "README.md",
     "LICENSE"