@pzy560117/opentest 0.1.4 → 0.1.5

package/README.md

@@ -26,10 +26,19 @@ requirement / design
 
 ## Install
 
-Install English OpenTest skills for Codex in the current project:
+Install the package, then run the initializer from any project:
 
 ```bash
-npx @pzy560117/opentest install --scope project --platform codex --language en
+npm install -g @pzy560117/opentest
+opentest init
+```
+
+`opentest init` lets you choose the target tool, language, project/global scope, and project path. This is the recommended path for Claude Code, Codex, Cursor, OpenCode, Gemini CLI, Qwen Code, and Qoder users.
+
+You can still run fully scripted installs. For example, install Chinese OpenTest skills for Claude Code in the current project:
+
+```bash
+opentest install --scope project --platform claude --language zh
 ```
 
 Install Chinese OpenTest skills for Qoder in a specific project:
@@ -98,6 +107,7 @@ Restart the target AI programming tool or open a new session after installation
 
 ## Package Contents
 
-- `assets/skills/`: Codex skill files
+- `assets/skills/`: English skill files
+- `assets/skills-zh/`: Chinese skill files
 - `assets/manifest.json`: published asset manifest
 - `bin/opentest.js`: installer CLI

package/assets/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.4",
+  "version": "0.1.5",
   "languages": [
     {
       "id": "en",

package/bin/opentest.js

@@ -3,6 +3,8 @@
 import { readFileSync } from 'fs';
 import { copyFile, mkdir, readdir, rm, stat } from 'fs/promises';
 import path from 'path';
+import { createInterface } from 'readline/promises';
+import { stdin as input, stdout as output } from 'process';
 import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -42,13 +44,14 @@ function usage(exitCode = 0) {
   const text = `OpenTest skill installer
 
 Usage:
+  opentest init [--scope <project|global>] [--platform <id>] [--language <id>] [--project <path>] [--force]
   opentest install [--scope <project|global>] [--platform <id>] [--language <id>] [--project <path>] [--global] [--force]
   opentest list [--language <id>]
 
 Options:
   --scope SCOPE     Install scope: project or global (default: project)
-  --platform ID     Target platform: ${availableIds(manifest.platforms)} (default: codex)
-  --language ID     Skill language: ${availableIds(manifest.languages)} (default: en)
+  --platform ID     Target platform: ${availableIds(manifest.platforms)} (auto-detected when possible)
+  --language ID     Skill language: ${availableIds(manifest.languages)} (default: locale-aware)
   --project PATH    Project root for project scope (default: current directory)
   --global          Alias for --scope global --platform codex
   --force           Overwrite existing opentest skill directories
@@ -61,11 +64,12 @@ function parseArgs(argv) {
   const [command, ...rest] = argv;
   const options = {
     command,
-    scope: 'project',
-    platform: 'codex',
-    language: 'en',
+    scope: undefined,
+    platform: undefined,
+    language: undefined,
     force: false,
     project: process.cwd(),
+    explicitTarget: false,
   };
 
   for (let i = 0; i < rest.length; i += 1) {
@@ -73,28 +77,34 @@ function parseArgs(argv) {
     if (arg === '--global') {
       options.scope = 'global';
       options.platform = 'codex';
+      options.explicitTarget = true;
     } else if (arg === '--force') {
       options.force = true;
+      options.explicitTarget = true;
     } else if (arg === '--scope') {
       const value = rest[i + 1];
       if (!value) usage(1);
       options.scope = value;
+      options.explicitTarget = true;
       i += 1;
     } else if (arg === '--platform') {
       const value = rest[i + 1];
       if (!value) usage(1);
       options.platform = value;
+      options.explicitTarget = true;
       i += 1;
     } else if (arg === '--language') {
       const value = rest[i + 1];
       if (!value) usage(1);
       options.language = value;
+      options.explicitTarget = true;
       i += 1;
     } else if (arg === '--project') {
       const value = rest[i + 1];
       if (!value) usage(1);
       options.scope = 'project';
       options.project = path.resolve(value);
+      options.explicitTarget = true;
       i += 1;
     } else {
       usage(1);
@@ -116,6 +126,61 @@ function homeRelativePath(manifestPath) {
   return manifestPath.replace(/^~[\\/]/, '');
 }
 
+function platformById(platformId) {
+  return manifest.platforms.find((entry) => entry.id === platformId);
+}
+
+function languageById(languageId) {
+  return manifest.languages.find((entry) => entry.id === languageId);
+}
+
+async function detectPlatform(projectRoot) {
+  const envHints = [
+    ['OPENTEST_PLATFORM', process.env.OPENTEST_PLATFORM],
+    ['CLAUDECODE', process.env.CLAUDECODE ? 'claude' : undefined],
+    ['CLAUDE_CODE', process.env.CLAUDE_CODE ? 'claude' : undefined],
+    ['CODEX', process.env.CODEX ? 'codex' : undefined],
+  ];
+  for (const [, value] of envHints) {
+    if (value && platformById(value)) {
+      return value;
+    }
+  }
+
+  for (const platform of manifest.platforms) {
+    if (await exists(path.join(projectRoot, platform.projectSkillsDir))) {
+      return platform.id;
+    }
+  }
+
+  return undefined;
+}
+
+function detectLanguage() {
+  const explicit = process.env.OPENTEST_LANGUAGE;
+  if (explicit && languageById(explicit)) {
+    return explicit;
+  }
+
+  const localeText = [
+    process.env.LC_ALL,
+    process.env.LC_MESSAGES,
+    process.env.LANG,
+    Intl.DateTimeFormat().resolvedOptions().locale,
+  ].filter(Boolean).join(' ').toLowerCase();
+
+  return localeText.includes('zh') ? 'zh' : 'en';
+}
+
+async function withInstallDefaults(options) {
+  return {
+    ...options,
+    scope: options.scope ?? 'project',
+    platform: options.platform ?? await detectPlatform(options.project) ?? 'codex',
+    language: options.language ?? detectLanguage(),
+  };
+}
+
 function targetSkillsDir(options, platform) {
   if (options.scope === 'global') {
     return path.join(homeDir(), homeRelativePath(platform.globalSkillsDir));
@@ -150,6 +215,119 @@ async function exists(filePath) {
   return stat(filePath).then(() => true, () => false);
 }
 
+function formatChoiceList(entries) {
+  return entries.map((entry, index) => `${index + 1}) ${entry.name} [${entry.id}]`).join('\n');
+}
+
+function matchChoice(entries, answer) {
+  const trimmed = answer.trim().toLowerCase();
+  if (!trimmed) return undefined;
+
+  const numeric = Number.parseInt(trimmed, 10);
+  if (Number.isInteger(numeric) && numeric >= 1 && numeric <= entries.length) {
+    return entries[numeric - 1].id;
+  }
+
+  return entries.find((entry) => entry.id.toLowerCase() === trimmed)?.id;
+}
+
+async function askChoice(rl, label, entries, defaultId) {
+  const defaultEntry = entries.find((entry) => entry.id === defaultId) ?? entries[0];
+  for (;;) {
+    const answer = await rl.question(`${label}\n${formatChoiceList(entries)}\nChoose [${defaultEntry.id}]: `);
+    const selected = matchChoice(entries, answer) ?? (answer.trim() ? undefined : defaultEntry.id);
+    if (selected) {
+      return selected;
+    }
+    console.log(`Please enter a number or one of: ${availableIds(entries)}`);
+  }
+}
+
+async function askText(rl, label, defaultValue) {
+  const answer = await rl.question(`${label} [${defaultValue}]: `);
+  return answer.trim() || defaultValue;
+}
+
+async function askYesNo(rl, label, defaultValue = false) {
+  const suffix = defaultValue ? 'Y/n' : 'y/N';
+  for (;;) {
+    const answer = (await rl.question(`${label} [${suffix}]: `)).trim().toLowerCase();
+    if (!answer) return defaultValue;
+    if (['y', 'yes'].includes(answer)) return true;
+    if (['n', 'no'].includes(answer)) return false;
+    console.log('Please answer y or n.');
+  }
+}
+
+async function readPipedInput() {
+  return new Promise((resolve, reject) => {
+    let text = '';
+    input.setEncoding('utf8');
+    input.on('data', (chunk) => {
+      text += chunk;
+    });
+    input.on('end', () => resolve(text));
+    input.on('error', reject);
+    input.resume();
+  });
+}
+
+async function createPrompter() {
+  if (input.isTTY) {
+    return createInterface({ input, output });
+  }
+
+  const lines = (await readPipedInput()).split(/\r?\n/);
+  let index = 0;
+  return {
+    async question(prompt) {
+      output.write(prompt);
+      const answer = lines[index] ?? '';
+      index += 1;
+      return answer;
+    },
+    close() {},
+  };
+}
+
+async function hasManagedInstall(options, currentManifest) {
+  const platform = resolvePlatform(options.platform);
+  const target = targetSkillsDir(options, platform);
+  for (const skillDir of managedSkillDirs(currentManifest)) {
+    if (await exists(path.join(target, skillDir))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+async function promptInstallOptions(options, currentManifest) {
+  const defaults = await withInstallDefaults(options);
+  const rl = await createPrompter();
+
+  try {
+    console.log('OpenTest init\n');
+    defaults.platform = await askChoice(rl, 'Target AI coding tool:', manifest.platforms, defaults.platform);
+    defaults.language = await askChoice(rl, 'Skill language:', manifest.languages, defaults.language);
+    defaults.scope = await askChoice(rl, 'Install scope:', [
+      { id: 'project', name: 'Current project' },
+      { id: 'global', name: 'User global' },
+    ], defaults.scope);
+
+    if (defaults.scope === 'project') {
+      defaults.project = path.resolve(await askText(rl, 'Project root', defaults.project));
+    }
+
+    if (!defaults.force && await hasManagedInstall(defaults, currentManifest)) {
+      defaults.force = await askYesNo(rl, 'OpenTest skills already exist. Overwrite managed OpenTest directories?', false);
+    }
+
+    return defaults;
+  } finally {
+    rl.close();
+  }
+}
+
 async function copyManifestFile(sourceRoot, targetRoot, relativePath) {
   const src = path.join(sourceRoot, relativePath);
   const dest = path.join(targetRoot, relativePath);
@@ -207,17 +385,20 @@ async function main() {
     usage(0);
   }
 
-  const language = resolveLanguage(options.language);
-  const platform = resolvePlatform(options.platform);
-  resolveScope(options.scope);
-
   if (options.command === 'list') {
+    const language = resolveLanguage(options.language ?? detectLanguage());
     await listSkills(language);
     return;
   }
 
+  if (options.command === 'init' || (options.command === 'install' && !options.explicitTarget && process.stdin.isTTY)) {
+    const promptedOptions = await promptInstallOptions(options, manifest);
+    await install(promptedOptions, manifest);
+    return;
+  }
+
   if (options.command === 'install') {
-    await install(options, manifest);
+    await install(await withInstallDefaults(options), manifest);
     return;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pzy560117/opentest",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "OpenTest quality evidence lifecycle skills for Codex",
   "keywords": [
     "opentest",

package/scripts/smoke-test.js

@@ -418,6 +418,42 @@ async function assertInstallBehavior() {
     noForceResult.stderr.includes('already exists. Re-run with --force to overwrite.'),
     `[INSTALL] expected overwrite guidance for existing skill\n${noForceResult.stderr}`,
   );
+
+  const detectedProject = await makeTempDir('opentest-detected-');
+  const detectedResult = assertCliSucceeds(['install', '--project', detectedProject], {
+    env: {
+      OPENTEST_PLATFORM: 'claude',
+      OPENTEST_LANGUAGE: 'zh',
+    },
+  });
+  await assertExists(
+    path.join(detectedProject, '.claude', 'skills', 'opentest', 'SKILL.md'),
+    '[INSTALL] OPENTEST_PLATFORM=claude must install project skills into .claude/skills',
+  );
+  assert(detectedResult.stdout.includes('Platform: Claude Code'), '[INSTALL] detected output must include Platform: Claude Code');
+  assert(detectedResult.stdout.includes('Language: 中文'), '[INSTALL] detected output must include Language: 中文');
+}
+
+async function assertInitBehavior() {
+  const project = await makeTempDir('opentest-init-');
+  const initResult = assertCliSucceeds(['init'], {
+    input: `2\n2\n1\n${project}\n`,
+  });
+
+  await assertExists(
+    path.join(project, '.claude', 'skills', 'opentest', 'SKILL.md'),
+    '[INIT] interactive init must install Claude project skills when Claude Code is selected',
+  );
+  await assertExists(
+    path.join(project, '.claude', 'skills', 'opentest', 'scripts', 'opentest-state.sh'),
+    '[INIT] interactive init must install shared OpenTest scripts',
+  );
+  assert(initResult.stdout.includes('OpenTest init'), '[INIT] output must show init wizard heading');
+  assert(initResult.stdout.includes('Target AI coding tool:'), '[INIT] output must prompt for platform');
+  assert(initResult.stdout.includes('Skill language:'), '[INIT] output must prompt for language');
+  assert(initResult.stdout.includes('Install scope:'), '[INIT] output must prompt for scope');
+  assert(initResult.stdout.includes('Platform: Claude Code'), '[INIT] output must include selected platform');
+  assert(initResult.stdout.includes('Language: 中文'), '[INIT] output must include selected language');
 }
 
 runManifestPathRelativitySelfCheck();
@@ -431,6 +467,7 @@ assertCliRejects(['install', '--language', 'jp'], 'Available languages: en, zh')
 assertCliRejects(['install', '--platform', 'invalid'], 'Available platforms: codex, claude, cursor, opencode, gemini, qwen, qoder');
 assertCliRejects(['install', '--scope', 'team'], 'Available scopes: project, global');
 await assertInstallBehavior();
+await assertInitBehavior();
 
 for (const assetPath of [...localizedFiles(), ...sharedAssetFiles()]) {
   const fullPath = path.join('assets', assetPath);