universal-dev-standards 3.0.0

package/src/utils/detector.js

@@ -0,0 +1,159 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Detect the programming language of the project
+ * @param {string} projectPath - Path to the project
+ * @returns {Object} Detected languages
+ */
+export function detectLanguage(projectPath) {
+  const detected = {
+    csharp: false,
+    php: false,
+    typescript: false,
+    javascript: false,
+    python: false
+  };
+
+  // Check for C# project files
+  if (existsSync(join(projectPath, '*.csproj')) ||
+      existsSync(join(projectPath, '*.sln')) ||
+      hasFileWithExtension(projectPath, '.csproj') ||
+      hasFileWithExtension(projectPath, '.cs')) {
+    detected.csharp = true;
+  }
+
+  // Check for PHP
+  if (existsSync(join(projectPath, 'composer.json')) ||
+      hasFileWithExtension(projectPath, '.php')) {
+    detected.php = true;
+  }
+
+  // Check for TypeScript
+  if (existsSync(join(projectPath, 'tsconfig.json')) ||
+      hasFileWithExtension(projectPath, '.ts') ||
+      hasFileWithExtension(projectPath, '.tsx')) {
+    detected.typescript = true;
+  }
+
+  // Check for JavaScript
+  if (existsSync(join(projectPath, 'package.json')) ||
+      hasFileWithExtension(projectPath, '.js') ||
+      hasFileWithExtension(projectPath, '.jsx')) {
+    detected.javascript = true;
+  }
+
+  // Check for Python
+  if (existsSync(join(projectPath, 'requirements.txt')) ||
+      existsSync(join(projectPath, 'setup.py')) ||
+      existsSync(join(projectPath, 'pyproject.toml')) ||
+      hasFileWithExtension(projectPath, '.py')) {
+    detected.python = true;
+  }
+
+  return detected;
+}
+
+/**
+ * Detect the framework used in the project
+ * @param {string} projectPath - Path to the project
+ * @returns {Object} Detected frameworks
+ */
+export function detectFramework(projectPath) {
+  const detected = {
+    'fat-free': false,
+    react: false,
+    vue: false,
+    angular: false,
+    dotnet: false
+  };
+
+  // Check for Fat-Free Framework (PHP)
+  const composerPath = join(projectPath, 'composer.json');
+  if (existsSync(composerPath)) {
+    try {
+      const composer = JSON.parse(readFileSync(composerPath, 'utf-8'));
+      const deps = { ...composer.require, ...composer['require-dev'] };
+      if (deps['bcosca/fatfree'] || deps['bcosca/fatfree-core']) {
+        detected['fat-free'] = true;
+      }
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  // Check for React/Vue/Angular
+  const packagePath = join(projectPath, 'package.json');
+  if (existsSync(packagePath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(packagePath, 'utf-8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps['react'] || deps['react-dom']) {
+        detected.react = true;
+      }
+      if (deps['vue']) {
+        detected.vue = true;
+      }
+      if (deps['@angular/core']) {
+        detected.angular = true;
+      }
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  // Check for .NET
+  if (hasFileWithExtension(projectPath, '.csproj') ||
+      hasFileWithExtension(projectPath, '.sln')) {
+    detected.dotnet = true;
+  }
+
+  return detected;
+}
+
+/**
+ * Detect AI tools configured in the project
+ * @param {string} projectPath - Path to the project
+ * @returns {Object} Detected AI tools
+ */
+export function detectAITools(projectPath) {
+  const detected = {
+    cursor: existsSync(join(projectPath, '.cursorrules')),
+    windsurf: existsSync(join(projectPath, '.windsurfrules')),
+    cline: existsSync(join(projectPath, '.clinerules')),
+    copilot: existsSync(join(projectPath, '.github', 'copilot-instructions.md')),
+    claudeCode: existsSync(join(projectPath, '.claude')) ||
+                existsSync(join(projectPath, 'CLAUDE.md')),
+    antigravity: existsSync(join(projectPath, 'INSTRUCTIONS.md'))
+  };
+
+  return detected;
+}
+
+/**
+ * Check if any file with the given extension exists in the directory
+ * @param {string} dirPath - Directory path
+ * @param {string} extension - File extension (with dot)
+ * @returns {boolean} True if file exists
+ */
+function hasFileWithExtension(dirPath, extension) {
+  try {
+    const files = readdirSync(dirPath);
+    return files.some(f => f.endsWith(extension));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get a summary of all detections
+ * @param {string} projectPath - Path to the project
+ * @returns {Object} Detection summary
+ */
+export function detectAll(projectPath) {
+  return {
+    languages: detectLanguage(projectPath),
+    frameworks: detectFramework(projectPath),
+    aiTools: detectAITools(projectPath)
+  };
+}

package/src/utils/github.js

@@ -0,0 +1,508 @@
+import { mkdirSync, writeFileSync, existsSync, readFileSync, readdirSync, copyFileSync } from 'fs';
+import { dirname, join, basename } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+import https from 'https';
+
+const GITHUB_RAW_BASE = 'https://raw.githubusercontent.com/AsiaOstrich/universal-dev-standards/main';
+const SKILLS_RAW_BASE = 'https://raw.githubusercontent.com/AsiaOstrich/universal-dev-standards/main/skills/claude-code';
+
+// Get the CLI package root directory
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const CLI_ROOT = join(__dirname, '..', '..');
+const SKILLS_LOCAL_DIR = join(CLI_ROOT, '..', 'skills', 'claude-code');
+
+/**
+ * Download a file from GitHub raw content
+ * @param {string} filePath - Path relative to repo root (e.g., 'core/checkin-standards.md')
+ * @returns {Promise<string>} File content
+ */
+export function downloadFromGitHub(filePath) {
+  const url = `${GITHUB_RAW_BASE}/${filePath}`;
+
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        // Follow redirect
+        https.get(res.headers.location, (redirectRes) => {
+          if (redirectRes.statusCode !== 200) {
+            reject(new Error(`GitHub returned ${redirectRes.statusCode} for ${filePath}`));
+            return;
+          }
+
+          let data = '';
+          redirectRes.on('data', chunk => data += chunk);
+          redirectRes.on('end', () => resolve(data));
+          redirectRes.on('error', reject);
+        }).on('error', reject);
+        return;
+      }
+
+      if (res.statusCode !== 200) {
+        reject(new Error(`GitHub returned ${res.statusCode} for ${filePath}`));
+        return;
+      }
+
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => resolve(data));
+      res.on('error', reject);
+    }).on('error', reject);
+  });
+}
+
+/**
+ * Download and save a standard file to the target project
+ * @param {string} sourcePath - Relative path from repo root (e.g., 'core/checkin-standards.md')
+ * @param {string} targetDir - Target directory (usually '.standards')
+ * @param {string} projectPath - Project root path
+ * @returns {Promise<Object>} Result with success status and copied path
+ */
+export async function downloadStandard(sourcePath, targetDir, projectPath) {
+  const targetFolder = join(projectPath, targetDir);
+  const targetFile = join(targetFolder, basename(sourcePath));
+
+  // Ensure target directory exists
+  if (!existsSync(targetFolder)) {
+    mkdirSync(targetFolder, { recursive: true });
+  }
+
+  try {
+    const content = await downloadFromGitHub(sourcePath);
+    writeFileSync(targetFile, content);
+    return {
+      success: true,
+      error: null,
+      path: targetFile
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message,
+      path: null
+    };
+  }
+}
+
+/**
+ * Download and save an integration file to its target location
+ * @param {string} sourcePath - Source path relative to repo root
+ * @param {string} targetPath - Target path relative to project root
+ * @param {string} projectPath - Project root path
+ * @returns {Promise<Object>} Result
+ */
+export async function downloadIntegration(sourcePath, targetPath, projectPath) {
+  const target = join(projectPath, targetPath);
+
+  // Ensure target directory exists
+  const targetDir = dirname(target);
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+
+  try {
+    const content = await downloadFromGitHub(sourcePath);
+    writeFileSync(target, content);
+    return {
+      success: true,
+      error: null,
+      path: target
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message,
+      path: null
+    };
+  }
+}
+
+/**
+ * Download a file from Skills repository
+ * @param {string} filePath - Path relative to skills repo root
+ * @returns {Promise<string>} File content
+ */
+export function downloadFromSkillsRepo(filePath) {
+  const url = `${SKILLS_RAW_BASE}/${filePath}`;
+
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        https.get(res.headers.location, (redirectRes) => {
+          if (redirectRes.statusCode !== 200) {
+            reject(new Error(`GitHub returned ${redirectRes.statusCode} for ${filePath}`));
+            return;
+          }
+
+          let data = '';
+          redirectRes.on('data', chunk => data += chunk);
+          redirectRes.on('end', () => resolve(data));
+          redirectRes.on('error', reject);
+        }).on('error', reject);
+        return;
+      }
+
+      if (res.statusCode !== 200) {
+        reject(new Error(`GitHub returned ${res.statusCode} for ${filePath}`));
+        return;
+      }
+
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => resolve(data));
+      res.on('error', reject);
+    }).on('error', reject);
+  });
+}
+
+/**
+ * Get the Skills installation directory
+ * @returns {string} Path to ~/.claude/skills/
+ */
+export function getSkillsDir() {
+  return join(homedir(), '.claude', 'skills');
+}
+
+/**
+ * Check if local skills directory exists
+ * @returns {boolean} True if local skills are available
+ */
+export function hasLocalSkills() {
+  return existsSync(SKILLS_LOCAL_DIR);
+}
+
+/**
+ * Get local skills directory path
+ * @returns {string} Path to local skills directory
+ */
+export function getLocalSkillsDir() {
+  return SKILLS_LOCAL_DIR;
+}
+
+/**
+ * Install a single Skill from local directory
+ * @param {string} skillName - Skill name (e.g., 'ai-collaboration-standards')
+ * @returns {Object} Result with success status
+ */
+export function installSkillFromLocal(skillName) {
+  const sourceDir = join(SKILLS_LOCAL_DIR, skillName);
+  const skillsDir = getSkillsDir();
+  const targetDir = join(skillsDir, skillName);
+
+  if (!existsSync(sourceDir)) {
+    return {
+      success: false,
+      skillName,
+      files: [],
+      error: `Skill directory not found: ${sourceDir}`,
+      path: null
+    };
+  }
+
+  // Ensure target directory exists
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+
+  const results = [];
+  try {
+    const files = readdirSync(sourceDir);
+    for (const fileName of files) {
+      const sourceFile = join(sourceDir, fileName);
+      const targetFile = join(targetDir, fileName);
+
+      try {
+        copyFileSync(sourceFile, targetFile);
+        results.push({ file: fileName, success: true });
+      } catch (error) {
+        results.push({ file: fileName, success: false, error: error.message });
+      }
+    }
+  } catch (error) {
+    return {
+      success: false,
+      skillName,
+      files: results,
+      error: error.message,
+      path: null
+    };
+  }
+
+  const allSuccess = results.every(r => r.success);
+  return {
+    success: allSuccess,
+    skillName,
+    files: results,
+    path: targetDir
+  };
+}
+
+/**
+ * Download and install a single Skill from remote repository
+ * @param {string} skillName - Skill name (e.g., 'ai-collaboration-standards')
+ * @param {string[]} skillFiles - Array of file paths relative to skills repo
+ * @returns {Promise<Object>} Result with success status
+ */
+export async function downloadSkill(skillName, skillFiles) {
+  // Prefer local installation if available
+  if (hasLocalSkills()) {
+    return installSkillFromLocal(skillName);
+  }
+
+  // Fall back to remote download
+  const skillsDir = getSkillsDir();
+  const targetDir = join(skillsDir, skillName);
+
+  // Ensure target directory exists
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+
+  const results = [];
+  for (const filePath of skillFiles) {
+    const fileName = basename(filePath);
+    const targetFile = join(targetDir, fileName);
+
+    try {
+      const content = await downloadFromSkillsRepo(filePath);
+      writeFileSync(targetFile, content);
+      results.push({ file: fileName, success: true });
+    } catch (error) {
+      results.push({ file: fileName, success: false, error: error.message });
+    }
+  }
+
+  const allSuccess = results.every(r => r.success);
+  return {
+    success: allSuccess,
+    skillName,
+    files: results,
+    path: targetDir
+  };
+}
+
+/**
+ * Check if Skills are already installed and get version info
+ * @returns {Object|null} Installed skills info or null
+ */
+export function getInstalledSkillsInfo() {
+  const skillsDir = getSkillsDir();
+  const manifestPath = join(skillsDir, '.manifest.json');
+
+  if (!existsSync(manifestPath)) {
+    // Check if any skill directories exist
+    if (!existsSync(skillsDir)) {
+      return null;
+    }
+
+    // Skills exist but no manifest - likely manually installed
+    return {
+      installed: true,
+      version: null,
+      source: 'unknown'
+    };
+  }
+
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    return {
+      installed: true,
+      version: manifest.version || null,
+      source: manifest.source || 'universal-dev-standards',
+      installedDate: manifest.installedDate || null
+    };
+  } catch {
+    return {
+      installed: true,
+      version: null,
+      source: 'unknown'
+    };
+  }
+}
+
+/**
+ * Write Skills manifest file
+ * @param {string} version - Version of skills installed
+ * @param {string} targetDir - Optional target directory (defaults to user-level)
+ */
+export function writeSkillsManifest(version, targetDir = null) {
+  const skillsDir = targetDir || getSkillsDir();
+  const manifestPath = join(skillsDir, '.manifest.json');
+
+  if (!existsSync(skillsDir)) {
+    mkdirSync(skillsDir, { recursive: true });
+  }
+
+  const manifest = {
+    version,
+    source: 'universal-dev-standards',
+    installedDate: new Date().toISOString().split('T')[0]
+  };
+
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+}
+
+/**
+ * Get the project-level Skills installation directory
+ * @param {string} projectPath - Project root path
+ * @returns {string} Path to project/.claude/skills/
+ */
+export function getProjectSkillsDir(projectPath) {
+  return join(projectPath, '.claude', 'skills');
+}
+
+/**
+ * Check if project-level Skills are installed and get version info
+ * @param {string} projectPath - Project root path
+ * @returns {Object|null} Installed skills info or null
+ */
+export function getProjectInstalledSkillsInfo(projectPath) {
+  const skillsDir = getProjectSkillsDir(projectPath);
+  const manifestPath = join(skillsDir, '.manifest.json');
+
+  if (!existsSync(manifestPath)) {
+    // Check if any skill directories exist
+    if (!existsSync(skillsDir)) {
+      return null;
+    }
+
+    // Skills exist but no manifest - likely manually installed
+    return {
+      installed: true,
+      version: null,
+      source: 'unknown',
+      location: 'project'
+    };
+  }
+
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+    return {
+      installed: true,
+      version: manifest.version || null,
+      source: manifest.source || 'universal-dev-standards',
+      installedDate: manifest.installedDate || null,
+      location: 'project'
+    };
+  } catch {
+    return {
+      installed: true,
+      version: null,
+      source: 'unknown',
+      location: 'project'
+    };
+  }
+}
+
+/**
+ * Install a single Skill to a specific target directory
+ * @param {string} skillName - Skill name (e.g., 'ai-collaboration-standards')
+ * @param {string} targetBaseDir - Target base directory for skills
+ * @returns {Object} Result with success status
+ */
+export function installSkillToDir(skillName, targetBaseDir) {
+  const sourceDir = join(SKILLS_LOCAL_DIR, skillName);
+  const targetDir = join(targetBaseDir, skillName);
+
+  if (!existsSync(sourceDir)) {
+    return {
+      success: false,
+      skillName,
+      files: [],
+      error: `Skill directory not found: ${sourceDir}`,
+      path: null
+    };
+  }
+
+  // Ensure target directory exists
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+
+  const results = [];
+  try {
+    const files = readdirSync(sourceDir);
+    for (const fileName of files) {
+      const sourceFile = join(sourceDir, fileName);
+      const targetFile = join(targetDir, fileName);
+
+      try {
+        copyFileSync(sourceFile, targetFile);
+        results.push({ file: fileName, success: true });
+      } catch (error) {
+        results.push({ file: fileName, success: false, error: error.message });
+      }
+    }
+  } catch (error) {
+    return {
+      success: false,
+      skillName,
+      files: results,
+      error: error.message,
+      path: null
+    };
+  }
+
+  const allSuccess = results.every(r => r.success);
+  return {
+    success: allSuccess,
+    skillName,
+    files: results,
+    path: targetDir
+  };
+}
+
+/**
+ * Download and install a single Skill to a specific target directory
+ * @param {string} skillName - Skill name
+ * @param {string[]} skillFiles - Array of file paths relative to skills repo
+ * @param {string} targetLocation - 'user' or 'project'
+ * @param {string} projectPath - Project path (required if targetLocation is 'project')
+ * @returns {Promise<Object>} Result with success status
+ */
+export async function downloadSkillToLocation(skillName, skillFiles, targetLocation = 'user', projectPath = null) {
+  // Determine target directory
+  const targetBaseDir = targetLocation === 'project' && projectPath
+    ? getProjectSkillsDir(projectPath)
+    : getSkillsDir();
+
+  // Prefer local installation if available
+  if (hasLocalSkills()) {
+    return installSkillToDir(skillName, targetBaseDir);
+  }
+
+  // Fall back to remote download
+  const targetDir = join(targetBaseDir, skillName);
+
+  // Ensure target directory exists
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+
+  const results = [];
+  for (const filePath of skillFiles) {
+    const fileName = basename(filePath);
+    const targetFile = join(targetDir, fileName);
+
+    try {
+      // For remote download, we need to extract just the skill-relative path
+      // skillFiles paths are like: skills/claude-code/ai-collaboration-standards/SKILL.md
+      // We need just: ai-collaboration-standards/SKILL.md
+      const relativePath = filePath.replace(/^skills\/claude-code\//, '');
+      const content = await downloadFromSkillsRepo(relativePath);
+      writeFileSync(targetFile, content);
+      results.push({ file: fileName, success: true });
+    } catch (error) {
+      results.push({ file: fileName, success: false, error: error.message });
+    }
+  }
+
+  const allSuccess = results.every(r => r.success);
+  return {
+    success: allSuccess,
+    skillName,
+    files: results,
+    path: targetDir
+  };
+}