@mingfuyun/star-allinone 0.3.2 → 0.4.0

package/scripts/gen/doctor.js

@@ -0,0 +1,293 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '../..');
+const SHARED_SKILLS = path.join(PACKAGE_ROOT, 'skills', 'shared');
+const DEFAULT_PREFIX = 'shared-';
+const LOCAL_OVERLAYS = ['CustomDrawer', 'BaseModal', 'HocModal'];
+const REQUIRED_CONFIG_KEYS = ['project', 'serviceDir'];
+const KNOWN_CONFIG_KEYS = new Set([
+  'project',
+  'publicSkillPrefix',
+  'serviceDir',
+  'openapi',
+  'publishPipelineId',
+  'sharedSkills',
+  'variables',
+]);
+const IGNORE_DIRS = new Set([
+  'node_modules',
+  'dist',
+  '.git',
+  '.umi',
+  'coverage',
+  '.turbo',
+]);
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+function existsAny(root, relatives) {
+  return relatives.find((relative) => fs.existsSync(path.join(root, relative)));
+}
+
+function walkFiles(dir, results = []) {
+  if (!fs.existsSync(dir)) return results;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (IGNORE_DIRS.has(entry.name)) continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkFiles(full, results);
+      continue;
+    }
+    if (/\.(ts|tsx|js|jsx)$/.test(entry.name)) results.push(full);
+  }
+  return results;
+}
+
+const TEMPLATE_EXT = new Set(['.md', '.json', '.yml', '.yaml', '.txt']);
+
+function render(content, variables) {
+  return content.replace(/\{\{\s*([\w.-]+)\s*\}\}/g, (_, key) => {
+    const value = key.split('.').reduce((current, part) => current?.[part], variables);
+    return value == null ? `{{${key}}}` : String(value);
+  });
+}
+
+function hashTree(dir, variables) {
+  if (!fs.existsSync(dir)) return '';
+  const files = [];
+  const walk = (current, relative) => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const nextRel = relative ? `${relative}/${entry.name}` : entry.name;
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(full, nextRel);
+        continue;
+      }
+      let content = fs.readFileSync(full);
+      if (variables && TEMPLATE_EXT.has(path.extname(entry.name).toLowerCase())) {
+        content = Buffer.from(render(content.toString('utf8'), variables));
+      }
+      files.push({ rel: nextRel, content });
+    }
+  };
+  walk(dir, '');
+  files.sort((a, b) => a.rel.localeCompare(b.rel));
+  const digest = crypto.createHash('sha256');
+  for (const file of files) {
+    digest.update(file.rel);
+    digest.update('\0');
+    digest.update(file.content);
+    digest.update('\0');
+  }
+  return digest.digest('hex');
+}
+
+function listPackageSkills() {
+  if (!fs.existsSync(SHARED_SKILLS)) return [];
+  return fs.readdirSync(SHARED_SKILLS, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort();
+}
+
+function check(ok, level, message) {
+  return { ok, level, message };
+}
+
+function runDoctor(cwd, options = {}) {
+  const root = path.resolve(options.target || cwd);
+  const findings = [];
+  const configFile = path.join(root, '.star-allinone.json');
+
+  if (!fs.existsSync(configFile)) {
+    findings.push(check(false, 'error', `Missing ${path.relative(root, configFile)}`));
+    printReport(root, findings);
+    return findings;
+  }
+
+  let config;
+  try {
+    config = readJson(configFile);
+    findings.push(check(true, 'ok', '.star-allinone.json'));
+  } catch (error) {
+    findings.push(check(false, 'error', `.star-allinone.json is not valid JSON: ${error.message}`));
+    printReport(root, findings);
+    return findings;
+  }
+
+  const unknownKeys = Object.keys(config).filter((key) => !KNOWN_CONFIG_KEYS.has(key));
+  if (unknownKeys.length) {
+    findings.push(check(false, 'warn', `Unknown config keys: ${unknownKeys.join(', ')}`));
+  }
+  for (const key of REQUIRED_CONFIG_KEYS) {
+    if (!config[key]) {
+      findings.push(check(false, 'error', `Config missing required "${key}"`));
+    }
+  }
+
+  const serviceDir = config.serviceDir || 'src/services';
+  if (!fs.existsSync(path.join(root, serviceDir))) {
+    findings.push(check(false, 'error', `serviceDir not found: ${serviceDir}`));
+  } else {
+    findings.push(check(true, 'ok', `serviceDir ${serviceDir}`));
+  }
+
+  const requestFile = existsAny(root, [
+    `${serviceDir}/request.tsx`,
+    `${serviceDir}/request.ts`,
+  ]);
+  if (!requestFile) {
+    findings.push(check(false, 'error', `MFRequest helper missing under ${serviceDir}/request.(ts|tsx)`));
+  } else {
+    const content = fs.readFileSync(path.join(root, requestFile), 'utf8');
+    if (!content.includes('MFRequest')) {
+      findings.push(check(false, 'error', `${requestFile} does not define MFRequest`));
+    } else {
+      findings.push(check(true, 'ok', requestFile));
+    }
+  }
+
+  if (config.openapi) {
+    if (fs.existsSync(path.join(root, config.openapi))) {
+      findings.push(check(true, 'ok', `openapi ${config.openapi}`));
+    } else {
+      findings.push(check(false, 'error', `openapi file not found: ${config.openapi}`));
+    }
+  } else {
+    findings.push(check(false, 'error', 'Config missing "openapi"'));
+  }
+
+  if (!config.publishPipelineId) {
+    findings.push(check(false, 'warn', 'Config missing "publishPipelineId"; $shared-publish-test cannot run'));
+  } else {
+    findings.push(check(true, 'ok', `publishPipelineId ${config.publishPipelineId}`));
+  }
+
+  const tableFile = existsAny(root, [
+    'src/components/CommonTable/MFProTable.tsx',
+    'src/components/CommonTable/MFProTable.ts',
+  ]);
+  if (!tableFile) {
+    findings.push(check(false, 'error', 'MFProTable missing at src/components/CommonTable/MFProTable.tsx (app-local, not this package)'));
+  } else {
+    findings.push(check(true, 'ok', tableFile));
+  }
+
+  if (!fs.existsSync(path.join(root, 'AGENTS.md'))) {
+    findings.push(check(false, 'warn', 'Missing AGENTS.md; run skills sync once to seed it'));
+  } else {
+    findings.push(check(true, 'ok', 'AGENTS.md'));
+  }
+
+  const prefix = config.publicSkillPrefix || DEFAULT_PREFIX;
+  const skillsDir = path.join(root, '.agents', 'skills');
+  const stampFile = path.join(skillsDir, '.star-allinone-sync.json');
+  const packageJson = readJson(path.join(PACKAGE_ROOT, 'package.json'));
+  if (fs.existsSync(stampFile)) {
+    try {
+      const stamp = readJson(stampFile);
+      if (stamp.packageVersion && stamp.packageVersion !== packageJson.version) {
+        findings.push(check(false, 'warn', `skills synced from ${stamp.packageVersion}, package is ${packageJson.version}. Run skills sync`));
+      } else {
+        findings.push(check(true, 'ok', `skills sync stamp ${stamp.packageVersion || packageJson.version}`));
+      }
+    } catch (error) {
+      findings.push(check(false, 'warn', `.star-allinone-sync.json is not valid JSON: ${error.message}`));
+    }
+  } else if (fs.existsSync(skillsDir)) {
+    findings.push(check(false, 'warn', 'Missing .agents/skills/.star-allinone-sync.json; run skills sync'));
+  }
+  const packageSkills = listPackageSkills();
+  if (!fs.existsSync(skillsDir)) {
+    findings.push(check(false, 'error', 'Missing .agents/skills. Run pnpm exec star-allinone skills sync'));
+    for (const skill of packageSkills) {
+      findings.push(check(false, 'error', `Shared skill not synced: ${prefix}${skill}. Run pnpm exec star-allinone skills sync`));
+    }
+  } else {
+    for (const skill of packageSkills) {
+      const publicName = `${prefix}${skill}`;
+      const dest = path.join(skillsDir, publicName);
+      const source = path.join(SHARED_SKILLS, skill);
+      if (!fs.existsSync(dest)) {
+        findings.push(check(false, 'error', `Shared skill not synced: ${publicName}. Run pnpm exec star-allinone skills sync`));
+        continue;
+      }
+      const variables = {
+        ...config,
+        ...config.variables,
+        sharedSkillName: publicName,
+        project: { ...config, ...config.variables },
+      };
+      if (hashTree(source, variables) !== hashTree(dest)) {
+        findings.push(check(false, 'warn', `${publicName} is stale vs this package. Run pnpm exec star-allinone skills sync`));
+      } else {
+        findings.push(check(true, 'ok', publicName));
+      }
+    }
+  }
+
+  const pkgFile = path.join(root, 'package.json');
+  if (fs.existsSync(pkgFile)) {
+    const pkg = readJson(pkgFile);
+    const dep = pkg.dependencies?.['@mingfuyun/star-allinone']
+      || pkg.devDependencies?.['@mingfuyun/star-allinone'];
+    if (!dep) {
+      findings.push(check(false, 'warn', 'package.json does not depend on @mingfuyun/star-allinone'));
+    } else {
+      findings.push(check(true, 'ok', `@mingfuyun/star-allinone ${dep}`));
+    }
+    const testScript = pkg.scripts?.test || '';
+    if (/\bmax\s+dev\b/.test(testScript)) {
+      findings.push(check(false, 'warn', 'package.json "test" runs max dev. Rename it to start:test / dev:test so agents do not treat it as unit tests'));
+    }
+  }
+
+  for (const overlay of LOCAL_OVERLAYS) {
+    const overlayDir = path.join(root, 'src/components', overlay);
+    if (fs.existsSync(overlayDir)) {
+      findings.push(check(false, 'error', `Local ${overlay} at src/components/${overlay} should be removed; import from @mingfuyun/star-allinone`));
+    }
+  }
+
+  const files = walkFiles(path.join(root, 'src'));
+  const badTable = [];
+  const localOverlay = [];
+  const tableFromPackage = /import\s+(?:type\s+)?(?:\{[^}]*\bMF(?:TablePro|ProTable)\b[^}]*\}|MF(?:TablePro|ProTable))\s+from\s+['"]@mingfuyun\/star-allinone['"]/;
+  const localDrawer = /from\s+['"]@\/components\/(?:CustomDrawer|BaseModal|HocModal)(?:\/[^'"]*)?['"]/;
+  for (const file of files) {
+    const content = fs.readFileSync(file, 'utf8');
+    const relative = path.relative(root, file);
+    if (tableFromPackage.test(content)) badTable.push(relative);
+    if (localDrawer.test(content)) localOverlay.push(relative);
+  }
+  if (badTable.length) {
+    findings.push(check(false, 'error', `MFProTable/MFTablePro imported from the npm package in ${badTable.join(', ')}. Use @/components/CommonTable/MFProTable`));
+  } else {
+    findings.push(check(true, 'ok', 'No table imports from @mingfuyun/star-allinone'));
+  }
+  if (localOverlay.length) {
+    findings.push(check(false, 'error', `Local overlay imports (use @mingfuyun/star-allinone): ${localOverlay.join(', ')}`));
+  } else {
+    findings.push(check(true, 'ok', 'Overlay imports use @mingfuyun/star-allinone or none found'));
+  }
+
+  printReport(root, findings);
+  return findings;
+}
+
+function printReport(root, findings) {
+  console.log(`star-allinone doctor (${root})`);
+  for (const item of findings) {
+    const tag = item.level === 'ok' ? 'OK  ' : item.level === 'warn' ? 'WARN' : 'ERR ';
+    console.log(`${tag}  ${item.message}`);
+  }
+  const errors = findings.filter((item) => item.level === 'error').length;
+  const warnings = findings.filter((item) => item.level === 'warn').length;
+  console.log(`\n${errors} error(s), ${warnings} warning(s)`);
+}
+
+module.exports = { runDoctor, hashTree };

package/scripts/gen/fields.js

@@ -0,0 +1,118 @@
+const { deref } = require('./spec');
+
+const SKIP_COLUMNS = new Set([
+  'created_at',
+  'updated_at',
+  'createTime',
+  'updateTime',
+  'deleted_at',
+]);
+
+const SKIP_FORM = new Set([
+  'id',
+  'pk',
+  'created_at',
+  'updated_at',
+  'createTime',
+  'updateTime',
+  'deleted_at',
+]);
+
+const SKIP_SEARCH = new Set([
+  'page',
+  'page_size',
+  'pageSize',
+  'current',
+  'limit',
+  'offset',
+  'ordering',
+  'sort',
+  'sort_by',
+]);
+
+function schemaType(schema) {
+  if (!schema) return undefined;
+  if (schema.enum?.length) return 'string';
+  const types = Array.isArray(schema.type)
+    ? schema.type.filter((item) => item !== 'null')
+    : [schema.type];
+  return types[0];
+}
+
+function fieldFromSchema(spec, name, schema, required) {
+  const resolved = deref(spec, schema) || {};
+  return {
+    name,
+    title: resolved.title || name,
+    required: Boolean(required),
+    type: schemaType(resolved),
+    format: resolved.format,
+    enum: Array.isArray(resolved.enum) ? resolved.enum : undefined,
+    readOnly: Boolean(resolved.readOnly),
+  };
+}
+
+function schemaFields(spec, schema, options = {}) {
+  if (!spec || !schema) return [];
+  const skip = options.skip || SKIP_COLUMNS;
+  const resolved = deref(spec, schema);
+  const properties = resolved?.properties || {};
+  const required = new Set(resolved?.required || []);
+  const fields = [];
+  for (const [name, prop] of Object.entries(properties)) {
+    if (skip.has(name)) continue;
+    const field = fieldFromSchema(spec, name, prop, required.has(name));
+    if (options.forForm && field.readOnly) continue;
+    fields.push(field);
+  }
+  if (typeof options.limit === 'number') return fields.slice(0, options.limit);
+  return fields;
+}
+
+function formComponent(field) {
+  if (field.enum?.length) return 'ProFormSelect';
+  if (field.type === 'boolean') return 'ProFormSwitch';
+  if (field.type === 'integer' || field.type === 'number') return 'ProFormDigit';
+  if (field.format === 'date-time') return 'ProFormDateTimePicker';
+  if (field.format === 'date') return 'ProFormDatePicker';
+  if (/desc|note|remark|comment|content|message/i.test(field.name)) return 'ProFormTextArea';
+  return 'ProFormText';
+}
+
+function columnValueType(field) {
+  if (field.enum?.length) return 'select';
+  if (field.type === 'boolean') return 'select';
+  if (field.type === 'integer' || field.type === 'number') return 'digit';
+  if (field.format === 'date-time') return 'dateTime';
+  if (field.format === 'date') return 'date';
+  return undefined;
+}
+
+function fallbackFields(itemTypeSource = '') {
+  const names = [...itemTypeSource.matchAll(/^\s+(\w+)\??:/gm)]
+    .map((match) => match[1])
+    .filter((name) => !SKIP_COLUMNS.has(name));
+  return names.slice(0, 6).map((name) => ({
+    name,
+    title: name,
+    required: false,
+    type: 'string',
+  }));
+}
+
+function querySearchNames(queryParams = []) {
+  return queryParams
+    .map((param) => param?.name)
+    .filter((name) => name && !SKIP_SEARCH.has(name));
+}
+
+module.exports = {
+  SKIP_COLUMNS,
+  SKIP_FORM,
+  SKIP_SEARCH,
+  schemaFields,
+  formComponent,
+  columnValueType,
+  fallbackFields,
+  querySearchNames,
+};

package/scripts/gen/fixtures/run.js

@@ -3,6 +3,7 @@ const os = require('os');
 const path = require('path');
 const { generateService } = require('../service');
 const { generatePage } = require('../page');
+const { runDoctor } = require('../doctor');
 
 function assert(condition, message) {
   if (!condition) throw new Error(message);
@@ -15,6 +16,7 @@ function makeProject() {
     JSON.stringify(
       {
         project: 'fixture',
+        publicSkillPrefix: 'shared-',
         serviceDir: 'src/services',
         openapi: 'openapi.json',
       },
@@ -45,10 +47,41 @@ function makeProject() {
 `,
   );
   fs.mkdirSync(path.join(root, 'src/components/CommonTable'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'src/components/CommonTable/MFProTable.tsx'), 'export default function MFProTable() { return null; }\n');
   fs.mkdirSync(path.join(root, 'src/pages'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({
+    dependencies: { '@mingfuyun/star-allinone': '^0.3.2' },
+    scripts: { typecheck: 'tsc --noEmit' },
+  }, null, 2));
   return root;
 }
 
+function writeContainerConfig(root) {
+  const dir = path.join(root, 'src/components/Page/Container');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(
+    path.join(dir, 'config.tsx'),
+    `export default {
+  '/existing': [
+    { key: 'tab-existing', label: 'Existing', loader: () => import('@/pages/Existing/components/List') },
+  ],
+};
+`,
+  );
+}
+
+function generateWidgetsPage(root, feature = 'Widgets', route = '/widgets') {
+  generatePage(root, {
+    feature,
+    route,
+    title: '组件管理',
+    listOperation: 'GET /api/v1/widgets/',
+    createOperation: 'POST /api/v1/widgets/',
+    updateOperation: 'PATCH /api/v1/widgets/{id}/',
+    deleteOperation: 'DELETE /api/v1/widgets/{id}/',
+  });
+}
+
 function main() {
   const root = makeProject();
   const first = generateService(root, {
@@ -78,21 +111,56 @@ function main() {
   assert(patched.includes('widgetsPartialUpdate'), patched);
   assert(patched.includes('MFRequest.patch<WIDGETS_API.Widget>'), patched);
 
-  generatePage(root, {
-    feature: 'Widgets',
-    route: '/widgets',
-    title: '组件管理',
-    listOperation: 'GET /api/v1/widgets/',
-    createOperation: 'POST /api/v1/widgets/',
-    updateOperation: 'PATCH /api/v1/widgets/{id}/',
-    deleteOperation: 'DELETE /api/v1/widgets/{id}/',
-  });
+  generateWidgetsPage(root);
   const page = fs.readFileSync(path.join(root, 'src/pages/Widgets/index.tsx'), 'utf8');
   assert(page.includes('Service.widgetsList'), page);
-  assert(page.includes("rowKey=\"id\""), page);
+  assert(page.includes('rowKey="id"'), page);
+  const columns = fs.readFileSync(path.join(root, 'src/pages/Widgets/const.tsx'), 'utf8');
+  assert(columns.includes("dataIndex: 'name'"), columns);
+  assert(columns.includes("dataIndex: 'kind'"), columns);
+  assert(columns.includes("valueType: 'select'"), columns);
+  assert(columns.includes("valueType: 'digit'"), columns);
+  const drawer = fs.readFileSync(path.join(root, 'src/pages/Widgets/components/WidgetsDrawer.tsx'), 'utf8');
+  assert(drawer.includes('ProFormSelect'), drawer);
+  assert(drawer.includes("name=\"status\""), drawer);
+  assert(drawer.includes("name=\"name\""), drawer);
+  assert(drawer.includes('required: true'), drawer);
   const route = fs.readFileSync(path.join(root, 'config/route.ts'), 'utf8');
   assert(route.includes("path: '/widgets'"), route);
+
+  const tabRoot = makeProject();
+  writeContainerConfig(tabRoot);
+  generateService(tabRoot, { operation: 'GET /api/v1/widgets/' });
+  generateWidgetsPage(tabRoot);
+  const shell = fs.readFileSync(path.join(tabRoot, 'src/pages/Widgets/index.tsx'), 'utf8');
+  assert(shell.includes("import Container from '@/components/Page/Container'"), shell);
+  const list = fs.readFileSync(path.join(tabRoot, 'src/pages/Widgets/components/List.tsx'), 'utf8');
+  assert(list.includes('Service.widgetsList'), list);
+  const tabConfig = fs.readFileSync(path.join(tabRoot, 'src/components/Page/Container/config.tsx'), 'utf8');
+  assert(tabConfig.includes("'/widgets'"), tabConfig);
+  assert(tabConfig.includes("@/pages/Widgets/components/List"), tabConfig);
+  assert(tabConfig.includes("loader: () => import('@/pages/Widgets/components/List')"), tabConfig);
+  assert(!tabConfig.includes('children: <Widgets'), tabConfig);
+  assert(!/import Widgets from/.test(tabConfig), tabConfig);
+
+  const healthy = runDoctor(root);
+  assert(healthy.some((item) => item.message.includes('MFProTable')), JSON.stringify(healthy));
+  assert(!healthy.some((item) => item.level === 'error' && item.message.includes('MFRequest')), JSON.stringify(healthy));
+
+  fs.mkdirSync(path.join(root, 'src/pages/Bad'), { recursive: true });
+  fs.writeFileSync(
+    path.join(root, 'src/pages/Bad/index.tsx'),
+    "import { MFTablePro } from '@mingfuyun/star-allinone';\nimport CustomDrawer from '@/components/CustomDrawer';\n",
+  );
+  fs.mkdirSync(path.join(root, 'src/components/CustomDrawer'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'src/components/CustomDrawer/index.tsx'), 'export default function CustomDrawer() { return null; }\n');
+  const sick = runDoctor(root);
+  assert(sick.some((item) => item.level === 'error' && /MFTablePro/.test(item.message)), JSON.stringify(sick));
+  assert(sick.some((item) => item.level === 'error' && /Local overlay/.test(item.message)), JSON.stringify(sick));
+
   fs.rmSync(root, { recursive: true, force: true });
+  fs.rmSync(tabRoot, { recursive: true, force: true });
+  process.exitCode = 0;
   console.log('codegen fixtures passed');
 }
 

package/scripts/gen/fixtures/widgets.openapi.json

@@ -165,6 +165,7 @@
         "properties": {
           "id": { "type": "string" },
           "name": { "type": "string" },
+          "kind": { "type": "string", "enum": ["gadget", "tool"] },
           "status": { "type": "string", "nullable": true },
           "count": { "type": "integer" }
         }
@@ -174,7 +175,7 @@
         "required": ["name"],
         "properties": {
           "name": { "type": "string" },
-          "status": { "type": "string" }
+          "status": { "type": "string", "enum": ["active", "inactive"] }
         }
       },
       "WidgetList": {