@ngocsangairvds/vsaf 4.0.9 → 4.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngocsangairvds/vsaf",
-  "version": "4.0.9",
+  "version": "4.0.10",
   "description": "is it ready to use ?",
   "main": "packages/core/dist/index.js",
   "types": "packages/core/dist/index.d.ts",

package/skills/vds-skill/_shared/config-check.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * config-check.js — reusable pre-flight checker for vds-skill-* SKILL.md files.
+ *
+ * Usage:
+ *   node config-check.js --cmd vds-cli --env VDS_CONFLUENCE_TOKEN,VDS_CONFLUENCE_SPACE_DEFAULT
+ *
+ * Output (matches legacy bash format):
+ *   OK                                          — all checks pass
+ *   BLOCKED — missing: vds-cli VDS_JIRA_TOKEN   — something missing
+ *   NOTE: /path/to/cmd exists but fails to run  — broken shim detected
+ */
+
+const { join } = require('path');
+const { loadCredentials, requireCommand } = require('./credentials.js');
+
+// ── Parse args ──
+
+const args = process.argv.slice(2);
+const cmds = [];
+const envVars = [];
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--cmd' && args[i + 1]) {
+    cmds.push(args[++i]);
+  } else if (args[i] === '--env' && args[i + 1]) {
+    envVars.push(...args[++i].split(',').map(s => s.trim()).filter(Boolean));
+  }
+}
+
+// ── Load credentials ──
+
+loadCredentials();
+
+// Prepend .claude/bin to PATH so vds-cli wrapper is found
+const localBin = join('.claude', 'bin');
+const sep = process.platform === 'win32' ? ';' : ':';
+process.env.PATH = `${localBin}${sep}${process.env.PATH}`;
+
+// ── Check commands ──
+
+const missing = [];
+const notes = [];
+
+for (const cmd of cmds) {
+  const result = requireCommand(cmd);
+  if (!result.found) {
+    missing.push(cmd);
+    if (result.broken && result.path) {
+      notes.push(`NOTE: ${result.path} exists but fails to run (broken shim or missing venv)`);
+    }
+  }
+}
+
+// ── Check env vars ──
+
+for (const varName of envVars) {
+  if (!process.env[varName]) {
+    missing.push(varName);
+  }
+}
+
+// ── Output ──
+
+for (const note of notes) {
+  console.log(note);
+}
+
+if (missing.length === 0) {
+  console.log('OK');
+} else {
+  console.log(`BLOCKED — missing: ${missing.join(' ')}`);
+  console.log('Fix: edit ~/.vds/sdlc-config.env (or run: vsaf install vds-skill)');
+}

package/skills/vds-skill/_shared/credentials.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+'use strict';
+
+const { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync, chmodSync, unlinkSync } = require('fs');
+const { join, dirname } = require('path');
+const { homedir } = require('os');
+const { execFileSync } = require('child_process');
+
+const IS_WIN = process.platform === 'win32';
+
+function getConfigPath() {
+  return process.env.VSAF_CONFIG_FILE || join(homedir(), '.vds', 'sdlc-config.env');
+}
+
+function parseEnvFile(filePath) {
+  if (!existsSync(filePath)) return {};
+  const vars = {};
+  for (const line of readFileSync(filePath, 'utf-8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eq = trimmed.indexOf('=');
+    if (eq <= 0) continue;
+    const key = trimmed.slice(0, eq);
+    let val = trimmed.slice(eq + 1);
+    if ((val.startsWith("'") && val.endsWith("'")) ||
+        (val.startsWith('"') && val.endsWith('"'))) {
+      val = val.slice(1, -1);
+    }
+    if (val) vars[key] = val;
+  }
+  return vars;
+}
+
+function loadCredentials() {
+  const configPath = getConfigPath();
+  const vdsEnvPath = join(homedir(), '.vds', '.env');
+
+  const primary = parseEnvFile(configPath);
+  for (const [key, val] of Object.entries(primary)) {
+    if (!process.env[key]) process.env[key] = val;
+  }
+
+  const fallback = parseEnvFile(vdsEnvPath);
+  for (const [key, val] of Object.entries(fallback)) {
+    if (!process.env[key]) process.env[key] = val;
+  }
+}
+
+function persistToConfig(varName, value) {
+  const configPath = getConfigPath();
+  mkdirSync(dirname(configPath), { recursive: true });
+
+  let content = '';
+  if (existsSync(configPath)) {
+    content = readFileSync(configPath, 'utf-8')
+      .split('\n')
+      .filter(line => !line.startsWith(`${varName}=`))
+      .join('\n');
+    if (content && !content.endsWith('\n')) content += '\n';
+  }
+  content += `${varName}=${value}\n`;
+
+  const tmp = configPath + '.tmp';
+  writeFileSync(tmp, content);
+  if (!IS_WIN) {
+    try { chmodSync(tmp, 0o600); } catch { /* warn but don't fail */ }
+  }
+  renameSync(tmp, configPath);
+}
+
+async function ensureEnv(varName, prompt, isSecret = true) {
+  if (process.env[varName]) return true;
+
+  if (!process.stdin.isTTY) return false;
+
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr,
+    terminal: true,
+  });
+
+  const value = await new Promise((resolve) => {
+    if (isSecret) {
+      process.stderr.write(`${prompt}: `);
+      const origWrite = process.stdout.write;
+      process.stdout.write = () => true;
+      rl.question('', (answer) => {
+        process.stdout.write = origWrite;
+        process.stderr.write('\n');
+        rl.close();
+        resolve(answer.trim());
+      });
+    } else {
+      rl.question(`${prompt}: `, (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    }
+  });
+
+  if (!value) {
+    process.stderr.write(`ERROR: ${varName} is required\n`);
+    return false;
+  }
+
+  process.env[varName] = value;
+  persistToConfig(varName, value);
+  return true;
+}
+
+function requireCommand(name) {
+  const localBin = join('.claude', 'bin', name);
+  if (existsSync(localBin)) {
+    try {
+      execFileSync(localBin, ['--version'], { stdio: 'pipe', timeout: 15000 });
+      return { found: true, path: localBin };
+    } catch {
+      return { found: false, path: localBin, broken: true };
+    }
+  }
+
+  const whichCmd = IS_WIN ? 'where' : 'which';
+  let cmdPath;
+  try {
+    cmdPath = execFileSync(whichCmd, [name], { stdio: 'pipe', encoding: 'utf-8' }).trim().split('\n')[0];
+  } catch {
+    return { found: false };
+  }
+
+  try {
+    execFileSync(name, ['--version'], { stdio: 'pipe', timeout: 15000 });
+    return { found: true, path: cmdPath };
+  } catch {
+    return { found: false, path: cmdPath, broken: true };
+  }
+}
+
+module.exports = { loadCredentials, ensureEnv, requireCommand, getConfigPath, parseEnvFile, persistToConfig };

package/skills/vds-skill/create-bitbucket-pr/SKILL.md

@@ -12,23 +12,7 @@ Create a Bitbucket PR on Viettel internal Bitbucket via `vds-cli`.
 Before doing anything, run this check via Bash tool:
 
 ```bash
-source .claude/skills/_shared/vds-skill/credentials.sh 2>/dev/null
-MISSING=""
-[[ -x .claude/bin/vds-cli ]] && export PATH=".claude/bin:$PATH"
-if ! vds-cli --version >/dev/null 2>&1; then
-  MISSING="$MISSING vds-cli"
-  VDS_PATH=$(command -v vds-cli 2>/dev/null)
-  if [[ -n "$VDS_PATH" ]]; then
-    echo "NOTE: $VDS_PATH exists but fails to run (broken shim or missing venv)"
-  fi
-fi
-[[ -z "${VDS_BITBUCKET_TOKEN:-}" ]] && MISSING="$MISSING VDS_BITBUCKET_TOKEN"
-if [[ -n "$MISSING" ]]; then
-  echo "BLOCKED — missing:$MISSING"
-  echo "Fix: edit ~/.vds/sdlc-config.env (or run: vsaf install vds-skill)"
-else
-  echo "OK"
-fi
+node .claude/skills/_shared/vds-skill/config-check.js --cmd vds-cli --env VDS_BITBUCKET_TOKEN
 ```
 
 If BLOCKED: tell the user exactly what's missing and how to fix, then STOP. Do NOT fabricate output. `--dry-run` mode skips credential + vds-cli checks.
@@ -63,7 +47,7 @@ If BLOCKED: tell the user exactly what's missing and how to fix, then STOP. Do N
 ## Implementation
 
 ```bash
-bash .claude/skills/vds-skill-create-bitbucket-pr/scripts/create-pr.sh "$@"
+node .claude/skills/vds-skill-create-bitbucket-pr/scripts/create-pr.js "$@"
 ```
 
 ## Notes

package/skills/vds-skill/create-bitbucket-pr/scripts/create-pr.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+'use strict';
+
+const { execFileSync } = require('child_process');
+const { existsSync, readdirSync } = require('fs');
+const { join } = require('path');
+// NOTE: path matches DEPLOYED location (.claude/skills/_shared/vds-skill/), not source repo
+const { loadCredentials, ensureEnv, requireCommand } = require('../../_shared/vds-skill/credentials.js');
+
+let dryRun = false;
+let targetBranch = 'master';
+let descFile = '';
+let title = '';
+
+const args = process.argv.slice(2);
+for (let i = 0; i < args.length; i++) {
+  switch (args[i]) {
+    case '--dry-run': dryRun = true; break;
+    case '--target': targetBranch = args[++i]; break;
+    case '--description-file': descFile = args[++i]; break;
+    case '--title': title = args[++i]; break;
+    default:
+      process.stderr.write(`Unknown arg: ${args[i]}\n`);
+      process.exit(2);
+  }
+}
+
+let remoteUrl;
+try {
+  remoteUrl = execFileSync('git', ['remote', 'get-url', 'origin'], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+} catch {
+  process.stderr.write('ERROR: No git remote \'origin\' configured\n');
+  process.exit(1);
+}
+
+if (!remoteUrl.includes('bitbucket.digital.vn')) {
+  process.stderr.write(`WARNING: Remote URL does not match bitbucket.digital.vn pattern:\n  ${remoteUrl}\n`);
+  process.stderr.write('  This skill is for Viettel Bitbucket. For GitHub, use \'gh pr create\'.\n');
+  process.exit(1);
+}
+
+const scmMatch = remoteUrl.match(/\/scm\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+const sshMatch = remoteUrl.match(/\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+const match = scmMatch || sshMatch;
+
+if (!match) {
+  process.stderr.write(`ERROR: Cannot parse PROJECT/REPO from remote URL: ${remoteUrl}\n`);
+  process.exit(1);
+}
+
+const project = match[1];
+const repo = match[2];
+
+let sourceBranch;
+try {
+  sourceBranch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+} catch {
+  process.stderr.write('ERROR: Cannot determine current branch\n');
+  process.exit(1);
+}
+
+if (!sourceBranch || sourceBranch === 'HEAD') {
+  process.stderr.write('ERROR: Not on a named branch\n');
+  process.exit(1);
+}
+
+if (!title) {
+  try {
+    title = execFileSync('git', ['log', '-1', '--pretty=%s'], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch { title = sourceBranch; }
+}
+
+if (!descFile) {
+  const searchPaths = [
+    { dir: join('.vsaf', 'docs', 'features'), file: '09-ship.md' },
+    { dir: join('.vsaf', 'docs', 'hotfixes'), file: '03-ship.md' },
+  ];
+  for (const { dir, file } of searchPaths) {
+    if (existsSync(dir)) {
+      for (const subdir of readdirSync(dir)) {
+        const candidate = join(dir, subdir, file);
+        if (existsSync(candidate)) { descFile = candidate; break; }
+      }
+    }
+    if (descFile) break;
+  }
+}
+
+const cmdArgs = ['bitbucket', 'pr', 'create', `${project}/${repo}`,
+  '--source', sourceBranch, '--target', targetBranch, '--title', title];
+if (descFile && existsSync(descFile)) cmdArgs.push('--description-file', descFile);
+
+if (dryRun) {
+  console.log('DRY-RUN — would execute:');
+  console.log(`  vds-cli ${cmdArgs.join(' ')} --yes --json-only`);
+  process.exit(0);
+}
+
+loadCredentials();
+
+const cmdCheck = requireCommand('vds-cli');
+if (!cmdCheck.found) {
+  process.stderr.write('ERROR: vds-cli not found in PATH\n');
+  if (cmdCheck.broken) process.stderr.write(`NOTE: ${cmdCheck.path} exists but fails to run\n`);
+  process.exit(127);
+}
+
+(async () => {
+  if (!await ensureEnv('VDS_BITBUCKET_TOKEN', 'Enter VDS Bitbucket personal access token')) process.exit(1);
+
+  console.log('About to create PR:');
+  console.log(`  Project/Repo: ${project}/${repo}`);
+  console.log(`  Source:       ${sourceBranch}`);
+  console.log(`  Target:       ${targetBranch}`);
+  console.log(`  Title:        ${title}`);
+  console.log(`  Description:  ${descFile || '<empty>'}`);
+  console.log('');
+
+  try {
+    execFileSync('vds-cli', [...cmdArgs, '--yes', '--json-only'], { stdio: 'inherit' });
+  } catch (err) {
+    process.stderr.write(`ERROR: vds-cli failed: ${err.message}\n`);
+    process.exit(1);
+  }
+})();

package/skills/vds-skill/create-jira-epic/SKILL.md

@@ -12,24 +12,7 @@ Create a Jira Epic on Viettel Jira based on a PRD markdown file.
 Before doing anything, run this check via Bash tool:
 
 ```bash
-source .claude/skills/_shared/vds-skill/credentials.sh 2>/dev/null
-MISSING=""
-[[ -x .claude/bin/vds-cli ]] && export PATH=".claude/bin:$PATH"
-if ! vds-cli --version >/dev/null 2>&1; then
-  MISSING="$MISSING vds-cli"
-  VDS_PATH=$(command -v vds-cli 2>/dev/null)
-  if [[ -n "$VDS_PATH" ]]; then
-    echo "NOTE: $VDS_PATH exists but fails to run (broken shim or missing venv)"
-  fi
-fi
-[[ -z "${VDS_JIRA_TOKEN:-}" ]] && MISSING="$MISSING VDS_JIRA_TOKEN"
-[[ -z "${VDS_JIRA_PROJECT_DEFAULT:-}" ]] && MISSING="$MISSING VDS_JIRA_PROJECT_DEFAULT"
-if [[ -n "$MISSING" ]]; then
-  echo "BLOCKED — missing:$MISSING"
-  echo "Fix: edit ~/.vds/sdlc-config.env (or run: vsaf install vds-skill)"
-else
-  echo "OK"
-fi
+node .claude/skills/_shared/vds-skill/config-check.js --cmd vds-cli --env VDS_JIRA_TOKEN,VDS_JIRA_PROJECT_DEFAULT
 ```
 
 If BLOCKED: tell the user exactly what's missing and how to fix, then STOP. Do NOT fabricate output. `--dry-run` mode skips credential + vds-cli checks.
@@ -37,7 +20,6 @@ If BLOCKED: tell the user exactly what's missing and how to fix, then STOP. Do N
 ## Prerequisites
 
 - `vds-cli` installed (for non-dry-run)
-- `python3` installed
 - A PRD file exists at `.vsaf/docs/features/{feature}/02-prd.md`
 - `VDS_JIRA_TOKEN` + `VDS_JIRA_PROJECT_DEFAULT` in `~/.vds/sdlc-config.env`
 
@@ -63,7 +45,7 @@ If BLOCKED: tell the user exactly what's missing and how to fix, then STOP. Do N
 ## Implementation
 
 ```bash
-bash .claude/skills/vds-skill-create-jira-epic/scripts/create-epic.sh "$@"
+node .claude/skills/vds-skill-create-jira-epic/scripts/create-epic.js "$@"
 ```
 
 ## Notes

package/skills/vds-skill/create-jira-epic/scripts/create-epic.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+'use strict';
+
+const { execFileSync } = require('child_process');
+const { existsSync, readFileSync, writeFileSync, readdirSync, statSync } = require('fs');
+const { join, dirname, basename } = require('path');
+// NOTE: path matches DEPLOYED location (.claude/skills/_shared/vds-skill/), not source repo
+const { loadCredentials, ensureEnv, requireCommand } = require('../../_shared/vds-skill/credentials.js');
+
+let dryRun = false;
+let projectKey = '';
+let descFile = '';
+let featureName = '';
+
+const args = process.argv.slice(2);
+for (let i = 0; i < args.length; i++) {
+  switch (args[i]) {
+    case '--dry-run': dryRun = true; break;
+    case '--project': projectKey = args[++i]; break;
+    case '--description-file': descFile = args[++i]; break;
+    case '--feature': featureName = args[++i]; break;
+    default:
+      process.stderr.write(`Unknown arg: ${args[i]}\n`);
+      process.exit(2);
+  }
+}
+
+if (!descFile) {
+  if (featureName) {
+    const candidate = join('.vsaf', 'docs', 'features', featureName, '02-prd.md');
+    if (existsSync(candidate)) descFile = candidate;
+  }
+  if (!descFile) {
+    const featuresDir = join('.vsaf', 'docs', 'features');
+    if (existsSync(featuresDir)) {
+      let newest = null;
+      let newestMtime = 0;
+      for (const dir of readdirSync(featuresDir)) {
+        const prd = join(featuresDir, dir, '02-prd.md');
+        if (existsSync(prd)) {
+          const mtime = statSync(prd).mtimeMs;
+          if (mtime > newestMtime) { newest = prd; newestMtime = mtime; }
+        }
+      }
+      if (newest) descFile = newest;
+    }
+  }
+}
+
+if (!descFile || !existsSync(descFile)) {
+  process.stderr.write('ERROR: PRD file not found. Run /sdlc-prd first or specify --description-file\n');
+  process.exit(1);
+}
+
+if (!featureName) featureName = basename(dirname(descFile));
+
+const prdContent = readFileSync(descFile, 'utf-8');
+const h1Match = prdContent.match(/^# (.+)/m);
+const summary = h1Match ? h1Match[1].trim() : featureName;
+
+if (dryRun) {
+  loadCredentials();
+  const displayProject = projectKey || process.env.VDS_JIRA_PROJECT_DEFAULT || '<VDS_JIRA_PROJECT_DEFAULT>';
+  console.log('DRY-RUN — would execute:');
+  console.log(`  vds-cli jira create --project ${displayProject} --issuetype Epic --summary "${summary}" --description-file ${descFile} --yes --json-only`);
+  process.exit(0);
+}
+
+loadCredentials();
+
+const cmdCheck = requireCommand('vds-cli');
+if (!cmdCheck.found) {
+  process.stderr.write('ERROR: vds-cli not found in PATH\n');
+  if (cmdCheck.broken) process.stderr.write(`NOTE: ${cmdCheck.path} exists but fails to run\n`);
+  process.exit(127);
+}
+
+(async () => {
+  if (!await ensureEnv('VDS_JIRA_TOKEN', 'Enter VDS Jira personal access token')) process.exit(1);
+  if (!await ensureEnv('VDS_JIRA_PROJECT_DEFAULT', 'Enter default Jira project key (e.g. NTTC)', false)) process.exit(1);
+
+  projectKey = projectKey || process.env.VDS_JIRA_PROJECT_DEFAULT;
+
+  console.log('About to create Jira Epic:');
+  console.log(`  Project:      ${projectKey}`);
+  console.log(`  Summary:      ${summary}`);
+  console.log(`  Description:  ${descFile}`);
+  console.log(`  Feature:      ${featureName}`);
+  console.log('');
+
+  const cmdArgs = ['jira', 'create', '--project', projectKey, '--issuetype', 'Epic',
+    '--summary', summary, '--description-file', descFile, '--yes', '--json-only'];
+
+  let result;
+  try {
+    result = execFileSync('vds-cli', cmdArgs, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+  } catch (err) {
+    process.stderr.write(`ERROR: vds-cli failed: ${err.stderr || err.message}\n`);
+    process.exit(1);
+  }
+
+  let epicKey;
+  try {
+    const parsed = JSON.parse(result);
+    epicKey = parsed.key || '';
+  } catch {
+    process.stderr.write(`ERROR: Failed to parse vds-cli response\nResponse: ${result}\n`);
+    process.exit(1);
+  }
+
+  if (!epicKey) {
+    process.stderr.write(`ERROR: No epic key in response\nResponse: ${result}\n`);
+    process.exit(1);
+  }
+
+  const epicKeyFile = join(dirname(descFile), 'jira-epic-key.txt');
+  writeFileSync(epicKeyFile, epicKey + '\n');
+  console.log(`Created Jira Epic: ${epicKey}`);
+  console.log(`  Saved key to: ${epicKeyFile}`);
+})();

package/skills/vds-skill/install-deps.mjs

@@ -10,7 +10,7 @@
  *   node install-deps.mjs [projectPath]
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, cpSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, cpSync, chmodSync } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
 
@@ -77,7 +77,7 @@ if (!existsSync(CONFIG_FILE)) {
   const lines = [
     '# VDS Skill Pack — credential config',
     '# File: ~/.vds/sdlc-config.env',
-    '# Permissions: 600 (auto-set by credentials.sh)',
+    '# Permissions: 600 (auto-set by credentials.js)',
     '#',
     '# Fill in the values below. Skills will use these automatically.',
     '# To rotate a token: update the value here, skills pick it up next run.',
@@ -91,7 +91,10 @@ if (!existsSync(CONFIG_FILE)) {
     lines.push('');
   }
 
-  writeFileSync(CONFIG_FILE, lines.join('\n'), { mode: 0o600 });
+  writeFileSync(CONFIG_FILE, lines.join('\n'));
+  if (process.platform !== 'win32') {
+    chmodSync(CONFIG_FILE, 0o600);
+  }
   log('✅', `Config created: ${CONFIG_FILE}`);
 } else if (missing.length > 0) {
   // Append missing vars to existing config
@@ -105,7 +108,10 @@ if (!existsSync(CONFIG_FILE)) {
     }
   }
   if (appendLines.length > 1) {
-    writeFileSync(CONFIG_FILE, readFileSync(CONFIG_FILE, 'utf-8') + appendLines.join('\n'), { mode: 0o600 });
+    writeFileSync(CONFIG_FILE, readFileSync(CONFIG_FILE, 'utf-8') + appendLines.join('\n'));
+    if (process.platform !== 'win32') {
+      chmodSync(CONFIG_FILE, 0o600);
+    }
     log('✅', `Config updated: ${CONFIG_FILE}`);
   }
 } else {
@@ -184,17 +190,24 @@ try {
 if (!vdsCliFound && vdsScriptsDir) {
   const wrapperDir = join(projectPath, '.claude', 'bin');
   const wrapperPath = join(wrapperDir, 'vds-cli');
-  const uvRunner = join(vdsScriptsDir, 'scripts', 'worktree_uv.sh');
-
-  if (existsSync(uvRunner)) {
+  // Check vds-scripts has valid structure (pyproject.toml = uv project)
+  if (existsSync(join(vdsScriptsDir, 'pyproject.toml'))) {
     mkdirSync(wrapperDir, { recursive: true });
-    const wrapperContent = `#!/usr/bin/env bash
-# Project-local vds-cli wrapper — created by vsaf install vds-skill
-# Delegates to worktree_uv.sh in the detected vds-scripts directory.
-set -euo pipefail
-exec "${uvRunner}" run --directory "${vdsScriptsDir}" --package vds-cli vds-cli "$@"
+    const wrapperContent = `#!/usr/bin/env node
+// Project-local vds-cli wrapper — created by vsaf install vds-skill
+const { execFileSync } = require('child_process');
+try {
+  execFileSync('uv', ['run', '--directory', ${JSON.stringify(vdsScriptsDir)}, '--package', 'vds-cli', 'vds-cli', ...process.argv.slice(2)], { stdio: 'inherit' });
+} catch (e) {
+  process.exit(e.status || 1);
+}
 `;
-    writeFileSync(wrapperPath, wrapperContent, { mode: 0o755 });
+    writeFileSync(wrapperPath, wrapperContent);
+    if (process.platform !== 'win32') {
+      chmodSync(wrapperPath, 0o755);
+    } else {
+      writeFileSync(wrapperPath + '.cmd', `@node "%~dp0\\vds-cli" %*\r\n`);
+    }
     log('✅', `vds-cli wrapper created: ${wrapperPath}`);
     log('  ', `Points to: ${vdsScriptsDir}`);
     log('💡', 'Add to PATH:  export PATH=".claude/bin:$PATH"');
@@ -206,39 +219,27 @@ if (!vdsCliFound) {
   log('⚠️', 'vds-cli not found — required for non-dry-run execution');
   log('  ', 'Option 1: Clone vds-scripts into .claude/vds-scripts/ then re-run install');
   log('  ', 'Option 2: Install vds-cli globally (pip install / Viettel internal)');
-  log('  ', 'Verify:   command -v vds-cli && vds-cli --version');
+  log('  ', 'Verify:   vds-cli --version');
 }
 
 // ── Step 5: Sync all vds-scripts packages (ensures subcommand binaries exist) ──
 
 if (vdsScriptsDir) {
   log('📂', `vds-scripts: ${vdsScriptsDir}`);
-  const uvRunner = join(vdsScriptsDir, 'scripts', 'worktree_uv.sh');
-  if (existsSync(uvRunner)) {
+  if (existsSync(join(vdsScriptsDir, 'pyproject.toml'))) {
     console.log('');
     log('🔄', 'Syncing vds-scripts packages (uv sync --all-packages)...');
     try {
-      execSync(`"${uvRunner}" sync --directory "${vdsScriptsDir}" --all-packages`, {
+      execSync('uv sync --all-packages', {
         stdio: 'pipe',
         encoding: 'utf-8',
         timeout: 120000,
         cwd: vdsScriptsDir,
       });
       log('✅', 'All vds-scripts packages synced');
-    } catch (e) {
-      // Fallback: try direct uv sync
-      try {
-        execSync('uv sync --all-packages', {
-          stdio: 'pipe',
-          encoding: 'utf-8',
-          timeout: 120000,
-          cwd: vdsScriptsDir,
-        });
-        log('✅', 'All vds-scripts packages synced (direct uv)');
-      } catch {
-        log('⚠️', 'Failed to sync vds-scripts packages — subcommands like confluence/jira may not work');
-        log('  ', `Fix: cd ${vdsScriptsDir} && uv sync --all-packages`);
-      }
+    } catch {
+      log('⚠️', 'Failed to sync vds-scripts packages — subcommands like confluence/jira may not work');
+      log('  ', `Fix: cd ${vdsScriptsDir} && uv sync --all-packages`);
     }
   }
 } else {
@@ -268,7 +269,8 @@ try {
   } catch {
     // Check if a shim exists but is broken
     try {
-      const shimPath = execSync('command -v vds-cli', { stdio: 'pipe', encoding: 'utf-8' }).trim();
+      const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+      const shimPath = execSync(`${whichCmd} vds-cli`, { stdio: 'pipe', encoding: 'utf-8' }).trim().split('\n')[0];
       log('❌', `vds-cli BROKEN — ${shimPath} exists but fails to run`);
       log('  ', 'The shim likely points to a deleted venv or missing vds-scripts directory.');
       log('  ', `Fix: rm ${shimPath}  then re-run: vsaf install vds-skill`);