@openwebf/webf 0.24.0 → 0.24.2

package/dist/commands.js

@@ -12,6 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentsInitCommand = void 0;
 exports.generateCommand = generateCommand;
 exports.generateModuleCommand = generateModuleCommand;
 const child_process_1 = require("child_process");
@@ -25,6 +26,8 @@ const glob_1 = require("glob");
 const lodash_1 = __importDefault(require("lodash"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const yaml_1 = __importDefault(require("yaml"));
+const agents_1 = require("./agents");
+Object.defineProperty(exports, "agentsInitCommand", { enumerable: true, get: function () { return agents_1.agentsInitCommand; } });
 /**
  * Sanitize a package name to comply with npm naming rules
  * NPM package name rules:
@@ -146,10 +149,10 @@ const tsConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '..
 const gitignore = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/gitignore.tpl'), 'utf-8');
 const modulePackageJson = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/module.package.json.tpl'), 'utf-8');
 const moduleTsConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/module.tsconfig.json.tpl'), 'utf-8');
-const moduleTsUpConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/module.tsup.config.ts.tpl'), 'utf-8');
+const moduleTsDownConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/module.tsdown.config.ts.tpl'), 'utf-8');
 const reactPackageJson = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/react.package.json.tpl'), 'utf-8');
 const reactTsConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/react.tsconfig.json.tpl'), 'utf-8');
-const reactTsUpConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/react.tsup.config.ts.tpl'), 'utf-8');
+const reactTsDownConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/react.tsdown.config.ts.tpl'), 'utf-8');
 const reactIndexTpl = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/react.index.ts.tpl'), 'utf-8');
 const vuePackageJson = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/vue.package.json.tpl'), 'utf-8');
 const vueTsConfig = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../templates/vue.tsconfig.json.tpl'), 'utf-8');
@@ -357,9 +360,9 @@ function createCommand(target, options) {
         const tsConfigPath = path_1.default.join(target, 'tsconfig.json');
         const tsConfigContent = lodash_1.default.template(reactTsConfig)({});
         writeFileIfChanged(tsConfigPath, tsConfigContent);
-        const tsupConfigPath = path_1.default.join(target, 'tsup.config.ts');
-        const tsupConfigContent = lodash_1.default.template(reactTsUpConfig)({});
-        writeFileIfChanged(tsupConfigPath, tsupConfigContent);
+        const tsdownConfigPath = path_1.default.join(target, 'tsdown.config.ts');
+        const tsdownConfigContent = lodash_1.default.template(reactTsDownConfig)({});
+        writeFileIfChanged(tsdownConfigPath, tsdownConfigContent);
         const gitignorePath = path_1.default.join(target, '.gitignore');
         const gitignoreContent = lodash_1.default.template(gitignore)({});
         writeFileIfChanged(gitignorePath, gitignoreContent);
@@ -424,9 +427,9 @@ function createModuleProject(target, options) {
     const tsConfigPath = path_1.default.join(target, 'tsconfig.json');
     const tsConfigContent = lodash_1.default.template(moduleTsConfig)({});
     writeFileIfChanged(tsConfigPath, tsConfigContent);
-    const tsupConfigPath = path_1.default.join(target, 'tsup.config.ts');
-    const tsupConfigContent = lodash_1.default.template(moduleTsUpConfig)({});
-    writeFileIfChanged(tsupConfigPath, tsupConfigContent);
+    const tsdownConfigPath = path_1.default.join(target, 'tsdown.config.ts');
+    const tsdownConfigContent = lodash_1.default.template(moduleTsDownConfig)({});
+    writeFileIfChanged(tsdownConfigPath, tsdownConfigContent);
     if (!skipGitignore) {
         const gitignorePath = path_1.default.join(target, '.gitignore');
         const gitignoreContent = lodash_1.default.template(gitignore)({});
@@ -914,7 +917,7 @@ function generateModuleCommand(distPath, options) {
                 }]);
             packageName = packageNameAnswer.packageName;
         }
-        // Prevent npm scaffolding (package.json, tsup.config.ts, etc.) from being written into
+        // Prevent npm scaffolding (package.json, tsdown.config.ts, etc.) from being written into
         // the Flutter package itself. Force users to choose a separate output directory.
         if (resolvedDistPath === flutterPackageSrc) {
             console.error('\n❌ Output directory must not be the Flutter package root.');
@@ -954,6 +957,14 @@ function generateModuleCommand(distPath, options) {
             flutterPackageDir: flutterPackageSrc,
             command,
         });
+        // Copy README.md from the source Flutter package into the npm package root
+        const { copied } = copyReadmeToPackageRoot({
+            sourceRoot: flutterPackageSrc,
+            targetRoot: resolvedDistPath,
+        });
+        if (copied) {
+            console.log('📄 Copied README.md to package root');
+        }
         console.log('\nModule code generation completed successfully!');
         try {
             yield buildPackage(resolvedDistPath);

package/dist/generator.js

@@ -220,6 +220,7 @@ function dartGen(_a) {
 }
 function reactGen(_a) {
     return __awaiter(this, arguments, void 0, function* ({ source, target, exclude, packageName }) {
+        var _b, _c;
         (0, logger_1.group)('React Code Generation');
         (0, logger_1.time)('reactGen');
         const { source: normalizedSource, target: normalizedTarget } = validatePaths(source, target);
@@ -296,7 +297,8 @@ function reactGen(_a) {
         // Always build the full index content string for downstream tooling/logging
         const newExports = (0, react_1.generateReactIndex)(blobs);
         // Build desired export map: moduleSpecifier -> Set of names
-        const desiredExports = new Map();
+        const desiredValueExports = new Map();
+        const desiredTypeExports = new Map();
         const components = blobs.flatMap(blob => {
             const classObjects = blob.objects.filter(obj => obj instanceof declaration_1.ClassObject);
             const properties = classObjects.filter(object => object.name.endsWith('Properties'));
@@ -318,11 +320,12 @@ function reactGen(_a) {
         }
         for (const { className, fileName, relativeDir } of unique.values()) {
             const spec = `./${relativeDir ? `${relativeDir}/` : ''}${fileName}`;
-            if (!desiredExports.has(spec))
-                desiredExports.set(spec, new Set());
-            const set = desiredExports.get(spec);
-            set.add(className);
-            set.add(`${className}Element`);
+            if (!desiredValueExports.has(spec))
+                desiredValueExports.set(spec, new Set());
+            if (!desiredTypeExports.has(spec))
+                desiredTypeExports.set(spec, new Set());
+            desiredValueExports.get(spec).add(className);
+            desiredTypeExports.get(spec).add(`${className}Element`);
         }
         if (!fs_1.default.existsSync(indexFilePath)) {
             // No index.ts -> generate fresh file from template
@@ -344,24 +347,44 @@ function reactGen(_a) {
                             : undefined;
                         if (!moduleSpecifier)
                             continue;
-                        const desired = desiredExports.get(moduleSpecifier);
-                        if (!desired)
+                        const desiredValues = desiredValueExports.get(moduleSpecifier);
+                        const desiredTypes = desiredTypeExports.get(moduleSpecifier);
+                        if (!desiredValues && !desiredTypes)
                             continue;
+                        const declIsTypeOnly = Boolean(stmt.isTypeOnly);
                         for (const el of stmt.exportClause.elements) {
                             const name = el.name.getText(sourceFile);
-                            if (desired.has(name))
-                                desired.delete(name);
+                            const specIsTypeOnly = Boolean(el.isTypeOnly);
+                            const isTypeOnly = declIsTypeOnly || specIsTypeOnly;
+                            if (isTypeOnly) {
+                                if (desiredTypes === null || desiredTypes === void 0 ? void 0 : desiredTypes.has(name))
+                                    desiredTypes.delete(name);
+                            }
+                            else {
+                                if (desiredValues === null || desiredValues === void 0 ? void 0 : desiredValues.has(name))
+                                    desiredValues.delete(name);
+                            }
                         }
                     }
                 }
                 // Prepare new export lines for any remaining names
                 const lines = [];
-                for (const [spec, names] of desiredExports) {
-                    const missing = Array.from(names);
-                    if (missing.length === 0)
+                const specs = new Set([
+                    ...desiredValueExports.keys(),
+                    ...desiredTypeExports.keys()
+                ]);
+                for (const spec of specs) {
+                    const missingValues = Array.from((_b = desiredValueExports.get(spec)) !== null && _b !== void 0 ? _b : []);
+                    const missingTypes = Array.from((_c = desiredTypeExports.get(spec)) !== null && _c !== void 0 ? _c : []);
+                    if (missingValues.length === 0 && missingTypes.length === 0)
                         continue;
                     const specEscaped = spec.replace(/\\/g, '/');
-                    lines.push(`export { ${missing.join(', ')} } from "${specEscaped}";`);
+                    if (missingValues.length > 0) {
+                        lines.push(`export { ${missingValues.join(', ')} } from "${specEscaped}";`);
+                    }
+                    if (missingTypes.length > 0) {
+                        lines.push(`export type { ${missingTypes.join(', ')} } from "${specEscaped}";`);
+                    }
                 }
                 if (lines.length > 0) {
                     const appended = (existing.endsWith('\n') ? '' : '\n') + lines.join('\n') + '\n';
@@ -420,7 +443,7 @@ function reactGen(_a) {
                     (0, logger_1.debug)(`[react] Aggregated types - consts: ${constNames.join(', ') || '(none)'}; typeAliases: ${aliasNames.join(', ') || '(none)'}; enums: ${enumNames.join(', ') || '(none)'}\n`);
                     (0, logger_1.debug)(`[react] src/types.ts preview:\n` + typesContent.split('\n').slice(0, 20).join('\n'));
                 }
-                catch (_b) { }
+                catch (_d) { }
             }
             // Only re-export from index.ts when there are actual declarations to surface.
             if (hasAny) {
@@ -438,7 +461,7 @@ function reactGen(_a) {
                         }
                     }
                 }
-                catch (_c) { }
+                catch (_e) { }
             }
         }
         catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwebf/webf",
-  "version": "0.24.0",
+  "version": "0.24.2",
   "description": "Command line tools for WebF",
   "main": "index.js",
   "bin": {
@@ -39,6 +39,7 @@
   "dependencies": {
     "@microsoft/tsdoc": "^0.15.1",
     "@microsoft/tsdoc-config": "^0.17.1",
+    "@openwebf/claude-code-skills": "^1.0.1",
     "commander": "^14.0.0",
     "glob": "^10.4.5",
     "inquirer": "^8.2.6",

package/src/agents.ts

@@ -0,0 +1,267 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import yaml from 'yaml';
+
+type SkillInfo = {
+  directoryName: string;
+  name: string;
+  description?: string;
+  skillFileRelativePath: string;
+  referenceRelativePaths: string[];
+};
+
+type CopyStats = {
+  filesWritten: number;
+  filesUnchanged: number;
+  backupsCreated: number;
+};
+
+const WEBF_AGENTS_BLOCK_START = '<!-- webf-agents:init start -->';
+const WEBF_AGENTS_BLOCK_END = '<!-- webf-agents:init end -->';
+
+function ensureDirSync(dirPath: string) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function readFileIfExists(filePath: string): Buffer | null {
+  try {
+    return fs.readFileSync(filePath);
+  } catch (error: any) {
+    if (error?.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+function backupFileSync(filePath: string) {
+  const timestamp = new Date()
+    .toISOString()
+    .replace(/[:.]/g, '')
+    .replace('T', '')
+    .replace('Z', 'Z');
+  const backupPath = `${filePath}.bak.${timestamp}`;
+  fs.copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+
+function copyFileWithBackupSync(srcPath: string, destPath: string) {
+  const src = fs.readFileSync(srcPath);
+  const dest = readFileIfExists(destPath);
+
+  if (dest && Buffer.compare(src, dest) === 0) return { changed: false, backupPath: null as string | null };
+
+  ensureDirSync(path.dirname(destPath));
+  let backupPath: string | null = null;
+  if (dest) {
+    backupPath = backupFileSync(destPath);
+  }
+  fs.writeFileSync(destPath, src);
+  return { changed: true, backupPath };
+}
+
+function copyDirRecursiveSync(srcDir: string, destDir: string, stats: CopyStats) {
+  ensureDirSync(destDir);
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursiveSync(srcPath, destPath, stats);
+      continue;
+    }
+    if (entry.isFile()) {
+      const { changed, backupPath } = copyFileWithBackupSync(srcPath, destPath);
+      if (changed) stats.filesWritten += 1;
+      else stats.filesUnchanged += 1;
+      if (backupPath) stats.backupsCreated += 1;
+    }
+  }
+}
+
+function listFilesRecursiveSync(dirPath: string): string[] {
+  const out: string[] = [];
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...listFilesRecursiveSync(entryPath));
+      continue;
+    }
+    if (entry.isFile()) out.push(entryPath);
+  }
+  return out;
+}
+
+function toPosixRelativePath(fromDir: string, absolutePath: string) {
+  const rel = path.relative(fromDir, absolutePath);
+  return rel.split(path.sep).join('/');
+}
+
+function parseSkillFrontmatter(skillMd: string): { name?: string; description?: string } {
+  const trimmed = skillMd.trimStart();
+  if (!trimmed.startsWith('---')) return {};
+  const endIndex = trimmed.indexOf('\n---', 3);
+  if (endIndex === -1) return {};
+  const fm = trimmed.slice(3, endIndex).trim();
+  try {
+    const parsed = yaml.parse(fm) ?? {};
+    return { name: parsed?.name, description: parsed?.description };
+  } catch {
+    return {};
+  }
+}
+
+function updateOrAppendMarkedBlock(existing: string, newBlock: string): { content: string; action: 'replaced' | 'appended' } {
+  const startIndex = existing.indexOf(WEBF_AGENTS_BLOCK_START);
+  const endIndex = existing.indexOf(WEBF_AGENTS_BLOCK_END);
+
+  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+    const before = existing.slice(0, startIndex).trimEnd();
+    const after = existing.slice(endIndex + WEBF_AGENTS_BLOCK_END.length).trimStart();
+    const next = [before, newBlock.trim(), after].filter(Boolean).join('\n\n');
+    return { content: next + '\n', action: 'replaced' };
+  }
+
+  const content = existing.trimEnd();
+  return { content: (content ? content + '\n\n' : '') + newBlock.trim() + '\n', action: 'appended' };
+}
+
+function buildClaudeBlock(sourcePackageName: string, sourcePackageVersion: string, skills: SkillInfo[]) {
+  const lines: string[] = [];
+  lines.push(WEBF_AGENTS_BLOCK_START);
+  lines.push('## WebF Claude Code Skills');
+  lines.push('');
+  lines.push(`Source: \`${sourcePackageName}@${sourcePackageVersion}\``);
+  lines.push('');
+  lines.push('### Skills');
+  for (const skill of skills) {
+    const desc = skill.description ? ` — ${skill.description}` : '';
+    lines.push(`- \`${skill.name}\`${desc} (\`${skill.skillFileRelativePath}\`)`);
+  }
+
+  const anyReferences = skills.some(s => s.referenceRelativePaths.length > 0);
+  if (anyReferences) {
+    lines.push('');
+    lines.push('### References');
+    for (const skill of skills) {
+      if (skill.referenceRelativePaths.length === 0) continue;
+      const refs = skill.referenceRelativePaths.map(r => `\`${r}\``).join(', ');
+      lines.push(`- \`${skill.name}\`: ${refs}`);
+    }
+  }
+
+  lines.push(WEBF_AGENTS_BLOCK_END);
+  return lines.join('\n');
+}
+
+function resolveSkillsPackageRoot() {
+  const packageJsonPath = require.resolve('@openwebf/claude-code-skills/package.json');
+  const packageRoot = path.dirname(packageJsonPath);
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+  return {
+    packageRoot,
+    packageName: packageJson?.name ?? '@openwebf/claude-code-skills',
+    packageVersion: packageJson?.version ?? 'unknown',
+  };
+}
+
+function listSkillDirectories(skillsPackageRoot: string) {
+  const entries = fs.readdirSync(skillsPackageRoot, { withFileTypes: true });
+  const dirs = entries
+    .filter(e => e.isDirectory())
+    .map(e => e.name)
+    .filter(name => fs.existsSync(path.join(skillsPackageRoot, name, 'SKILL.md')))
+    .sort();
+  return dirs;
+}
+
+function collectSkillInfo(projectRoot: string, skillsDir: string, skillDirectoryName: string): SkillInfo {
+  const skillDirAbs = path.join(skillsDir, skillDirectoryName);
+  const skillMdAbs = path.join(skillDirAbs, 'SKILL.md');
+  const skillMd = fs.readFileSync(skillMdAbs, 'utf-8');
+  const fm = parseSkillFrontmatter(skillMd);
+
+  const referenceRelativePaths: string[] = [];
+  const files = listFilesRecursiveSync(skillDirAbs);
+  for (const fileAbs of files) {
+    if (path.basename(fileAbs) === 'SKILL.md') continue;
+    referenceRelativePaths.push(toPosixRelativePath(projectRoot, fileAbs));
+  }
+  referenceRelativePaths.sort();
+
+  return {
+    directoryName: skillDirectoryName,
+    name: fm.name ?? skillDirectoryName,
+    description: fm.description,
+    skillFileRelativePath: toPosixRelativePath(projectRoot, skillMdAbs),
+    referenceRelativePaths,
+  };
+}
+
+async function agentsInitCommand(projectDir: string): Promise<void> {
+  const startedAt = Date.now();
+  const resolvedProjectDir = path.resolve(process.cwd(), projectDir || '.');
+  const claudeMdPath = path.join(resolvedProjectDir, 'CLAUDE.md');
+  const claudeDir = path.join(resolvedProjectDir, '.claude');
+  const projectSkillsDir = path.join(claudeDir, 'skills');
+
+  const hasClaudeMd = fs.existsSync(claudeMdPath);
+  const hasClaudeDir = fs.existsSync(claudeDir);
+
+  const isNewProject = !hasClaudeMd && !hasClaudeDir;
+
+  console.log('webf agents init');
+  console.log(`Project: ${resolvedProjectDir}`);
+  if (isNewProject) {
+    console.log('Detected: no CLAUDE.md and no .claude/ (new project)');
+  } else {
+    console.log(`Detected: CLAUDE.md=${hasClaudeMd ? 'yes' : 'no'}, .claude/=${hasClaudeDir ? 'yes' : 'no'} (existing project)`);
+  }
+
+  const { packageRoot, packageName, packageVersion } = resolveSkillsPackageRoot();
+  const skillDirectories = listSkillDirectories(packageRoot);
+
+  if (skillDirectories.length === 0) {
+    throw new Error(`No skills found in ${packageName} (resolved at ${packageRoot}).`);
+  }
+
+  console.log(`Skills source: ${packageName}@${packageVersion}`);
+  console.log(`Skills destination: ${toPosixRelativePath(resolvedProjectDir, projectSkillsDir)}`);
+
+  ensureDirSync(projectSkillsDir);
+
+  const copyStats: CopyStats = { filesWritten: 0, filesUnchanged: 0, backupsCreated: 0 };
+  for (const skillDirName of skillDirectories) {
+    const srcSkillDir = path.join(packageRoot, skillDirName);
+    const destSkillDir = path.join(projectSkillsDir, skillDirName);
+
+    copyDirRecursiveSync(srcSkillDir, destSkillDir, copyStats);
+  }
+
+  const installedSkills = skillDirectories.map(skillDirName =>
+    collectSkillInfo(resolvedProjectDir, projectSkillsDir, skillDirName)
+  );
+
+  const block = buildClaudeBlock(packageName, packageVersion, installedSkills);
+
+  if (isNewProject) {
+    const initial = ['# Claude Code', '', block, ''].join('\n');
+    fs.writeFileSync(claudeMdPath, initial, 'utf-8');
+    console.log(`Created ${toPosixRelativePath(resolvedProjectDir, claudeMdPath)}`);
+  } else {
+    const existing = readFileIfExists(claudeMdPath)?.toString('utf-8') ?? '';
+    const { content, action } = updateOrAppendMarkedBlock(existing, block);
+    fs.writeFileSync(claudeMdPath, content, 'utf-8');
+    console.log(`${action === 'replaced' ? 'Updated' : 'Appended'} WebF skills block in ${toPosixRelativePath(resolvedProjectDir, claudeMdPath)}`);
+  }
+
+  const versionFilePath = path.join(claudeDir, 'webf-claude-code-skills.version');
+  fs.writeFileSync(versionFilePath, `${packageName}@${packageVersion}${os.EOL}`, 'utf-8');
+  console.log(`Wrote ${toPosixRelativePath(resolvedProjectDir, versionFilePath)}`);
+
+  console.log(
+    `Installed ${installedSkills.length} skills (${copyStats.filesWritten} files written, ${copyStats.filesUnchanged} unchanged, ${copyStats.backupsCreated} backups) in ${Date.now() - startedAt}ms`
+  );
+}
+
+export { agentsInitCommand };