@pzy560117/opentest 0.1.3 → 0.1.5

package/bin/opentest.js

@@ -1,25 +1,60 @@
 #!/usr/bin/env node
 
-import { cp, mkdir, readdir, rm, stat } from 'fs/promises';
+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);
 const __dirname = path.dirname(__filename);
 const packageRoot = path.resolve(__dirname, '..');
-const skillsSource = path.join(packageRoot, 'assets', 'skills');
+const manifest = JSON.parse(readFileSync(path.join(packageRoot, 'assets', 'manifest.json'), 'utf8'));
+
+function availableIds(entries) {
+  return entries.map((entry) => entry.id).join(', ');
+}
+
+function resolveLanguage(languageId) {
+  const language = manifest.languages.find((entry) => entry.id === languageId);
+  if (!language) {
+    throw new Error(`Invalid language: ${languageId}. Available languages: ${availableIds(manifest.languages)}`);
+  }
+  return language;
+}
+
+function resolvePlatform(platformId) {
+  const platform = manifest.platforms.find((entry) => entry.id === platformId);
+  if (!platform) {
+    throw new Error(`Invalid platform: ${platformId}. Available platforms: ${availableIds(manifest.platforms)}`);
+  }
+  return platform;
+}
+
+function resolveScope(scope) {
+  const scopes = ['project', 'global'];
+  if (!scopes.includes(scope)) {
+    throw new Error(`Invalid scope: ${scope}. Available scopes: ${scopes.join(', ')}`);
+  }
+  return scope;
+}
 
 function usage(exitCode = 0) {
   const text = `OpenTest skill installer
 
 Usage:
-  opentest install [--global] [--force] [--project <path>]
-  opentest list
+  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:
-  --global        Install to ~/.codex/skills instead of ./ .codex/skills
-  --project PATH  Install to PATH/.codex/skills
-  --force         Overwrite existing opentest skill directories
+  --scope SCOPE     Install scope: project or global (default: project)
+  --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
 `;
   (exitCode === 0 ? console.log : console.error)(text.trim());
   process.exit(exitCode);
@@ -27,18 +62,49 @@ Options:
 
 function parseArgs(argv) {
   const [command, ...rest] = argv;
-  const options = { command, global: false, force: false, project: process.cwd() };
+  const options = {
+    command,
+    scope: undefined,
+    platform: undefined,
+    language: undefined,
+    force: false,
+    project: process.cwd(),
+    explicitTarget: false,
+  };
 
   for (let i = 0; i < rest.length; i += 1) {
     const arg = rest[i];
     if (arg === '--global') {
-      options.global = true;
+      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);
@@ -56,44 +122,260 @@ function homeDir() {
   return home;
 }
 
-function targetSkillsDir(options) {
-  if (options.global) {
-    return path.join(homeDir(), '.codex', 'skills');
+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));
   }
-  return path.join(options.project, '.codex', 'skills');
+  return path.join(options.project, platform.projectSkillsDir);
 }
 
-async function listSkills() {
+async function listSkills(language) {
+  const skillsSource = path.join(packageRoot, 'assets', language.skillsDir);
   const entries = await readdir(skillsSource, { withFileTypes: true });
   for (const entry of entries.filter((item) => item.isDirectory()).map((item) => item.name).sort()) {
     console.log(entry);
   }
 }
 
-async function install(options) {
-  const target = targetSkillsDir(options);
+function managedSkillDirs(currentManifest) {
+  return [...new Set([
+    ...(currentManifest.managedFiles?.localized ?? []),
+    ...(currentManifest.managedFiles?.shared ?? []),
+  ].map((file) => file.split(/[\\/]+/)[0]).filter(Boolean))].sort();
+}
+
+function localizedSourceRoot(language) {
+  return path.join(packageRoot, 'assets', language.skillsDir);
+}
+
+function sharedSourceRoot() {
+  return path.join(packageRoot, 'assets', 'skills');
+}
+
+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);
+
+  if (!(await exists(src))) {
+    throw new Error(`Manifest-managed source file is missing: ${src}`);
+  }
+
+  await mkdir(path.dirname(dest), { recursive: true });
+  await copyFile(src, dest);
+}
+
+async function install(options, currentManifest) {
+  const language = resolveLanguage(options.language);
+  const platform = resolvePlatform(options.platform);
+  resolveScope(options.scope);
+
+  const target = targetSkillsDir(options, platform);
   await mkdir(target, { recursive: true });
 
-  const entries = await readdir(skillsSource, { withFileTypes: true });
-  const skillDirs = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith('opentest'));
+  const skillDirs = managedSkillDirs(currentManifest);
 
-  for (const entry of skillDirs) {
-    const src = path.join(skillsSource, entry.name);
-    const dest = path.join(target, entry.name);
-    const exists = await stat(dest).then(() => true, () => false);
+  for (const skillDir of skillDirs) {
+    const dest = path.join(target, skillDir);
+    const directoryExists = await exists(dest);
 
-    if (exists && !options.force) {
+    if (directoryExists && !options.force) {
       throw new Error(`${dest} already exists. Re-run with --force to overwrite.`);
     }
+  }
 
-    if (exists) {
-      await rm(dest, { recursive: true, force: true });
+  if (options.force) {
+    for (const skillDir of skillDirs) {
+      await rm(path.join(target, skillDir), { recursive: true, force: true });
     }
-    await cp(src, dest, { recursive: true });
+  }
+
+  for (const file of currentManifest.managedFiles?.localized ?? []) {
+    await copyManifestFile(localizedSourceRoot(language), target, file);
+  }
+  for (const file of currentManifest.managedFiles?.shared ?? []) {
+    await copyManifestFile(sharedSourceRoot(), target, file);
   }
 
   console.log(`Installed ${skillDirs.length} OpenTest skills to ${target}`);
-  console.log('Restart Codex or open a new session to pick up newly installed skills.');
+  console.log(`Platform: ${platform.name}`);
+  console.log(`Language: ${language.name}`);
+  console.log('Restart your AI coding tool or open a new session to pick up newly installed skills.');
 }
 
 async function main() {
@@ -104,12 +386,19 @@ async function main() {
   }
 
   if (options.command === 'list') {
-    await listSkills();
+    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);
+    await install(await withInstallDefaults(options), manifest);
     return;
   }
 

package/package.json

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

package/scripts/prepublish-check.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
-import { readFileSync, readdirSync, statSync } from 'fs';
-import { extname, join } from 'path';
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { basename, extname, join } from 'path';
+import { TextDecoder } from 'util';
 
 const SECRET_PATTERNS = [
   { pattern: /(?:api[_-]?key|apikey)\s*[:=]\s*['"][A-Za-z0-9_-]{20,}['"]/i, name: 'API key' },
@@ -14,7 +15,52 @@ const SECRET_PATTERNS = [
 ];
 
 const SKIP_DIRS = new Set(['node_modules', '.git']);
-const TEXT_EXTENSIONS = new Set(['.js', '.json', '.md', '.txt', '.yml', '.yaml', '.toml', '.sh']);
+const TEXT_EXTENSIONS = new Set([
+  '.js',
+  '.json',
+  '.md',
+  '.txt',
+  '.yml',
+  '.yaml',
+  '.toml',
+  '.sh',
+  '.env',
+  '.pem',
+  '.key',
+  '.crt',
+  '.cer',
+]);
+const DOT_TEXT_FILENAMES = new Set(['.env']);
+const MAX_TEXT_SCAN_BYTES = 1024 * 1024;
+const MAX_EXTENSIONLESS_TEXT_SCAN_BYTES = 64 * 1024;
+const utf8Decoder = new TextDecoder('utf-8', { fatal: true });
+
+function assertManifest(condition, message) {
+  if (!condition) {
+    console.error(`[MANIFEST] ${message}`);
+    process.exit(1);
+  }
+}
+
+function loadManifest() {
+  try {
+    return JSON.parse(readFileSync('assets/manifest.json', 'utf8'));
+  } catch (error) {
+    console.error(`[MANIFEST] failed to load assets/manifest.json: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+function validateManifestForPublish(manifest) {
+  assertManifest(Array.isArray(manifest.languages), 'languages must be an array');
+  assertManifest(
+    manifest.languages.some((entry) => entry.id === 'zh'),
+    'languages must include zh',
+  );
+  assertManifest(Array.isArray(manifest.managedFiles?.localized), 'managedFiles.localized must exist');
+  assertManifest(Array.isArray(manifest.managedFiles?.shared), 'managedFiles.shared must exist');
+  assertManifest(existsSync('assets/skills-zh') && statSync('assets/skills-zh').isDirectory(), 'assets/skills-zh must exist');
+}
 
 function* walkFiles(dir) {
   for (const entry of readdirSync(dir)) {
@@ -30,17 +76,70 @@ function* walkFiles(dir) {
   }
 }
 
+function scanByteLimit(filePath, fileStat) {
+  const filename = basename(filePath).toLowerCase();
+  const extension = extname(filename);
+
+  if (TEXT_EXTENSIONS.has(extension) || DOT_TEXT_FILENAMES.has(filename)) {
+    return MAX_TEXT_SCAN_BYTES;
+  }
+
+  if (extension === '' && fileStat.size <= MAX_EXTENSIONLESS_TEXT_SCAN_BYTES) {
+    return MAX_EXTENSIONLESS_TEXT_SCAN_BYTES;
+  }
+
+  return 0;
+}
+
+function looksLikeText(buffer) {
+  if (buffer.length === 0) {
+    return true;
+  }
+
+  let controlBytes = 0;
+  for (const byte of buffer) {
+    if (byte === 0) {
+      return false;
+    }
+    if (byte < 9 || (byte > 13 && byte < 32)) {
+      controlBytes += 1;
+    }
+  }
+
+  return controlBytes / buffer.length < 0.05;
+}
+
+function readScannableText(filePath) {
+  const fileStat = statSync(filePath);
+  const byteLimit = scanByteLimit(filePath, fileStat);
+  if (byteLimit === 0 || fileStat.size > byteLimit) {
+    return undefined;
+  }
+
+  const content = readFileSync(filePath);
+  if (!looksLikeText(content)) {
+    return undefined;
+  }
+
+  try {
+    return utf8Decoder.decode(content);
+  } catch {
+    return undefined;
+  }
+}
+
+validateManifestForPublish(loadManifest());
+
 let found = 0;
 
 for (const filePath of walkFiles('.')) {
-  if (!TEXT_EXTENSIONS.has(extname(filePath))) continue;
-
   let content;
   try {
-    content = readFileSync(filePath, 'utf8');
+    content = readScannableText(filePath);
   } catch {
     continue;
   }
+  if (content === undefined) continue;
 
   for (const { pattern, name } of SECRET_PATTERNS) {
     if (pattern.test(content)) {