@vibecuting/component-project-helper 0.1.16 → 0.1.18

package/src/meta/update-component-skills.ts

@@ -0,0 +1,306 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import ts from 'typescript'
+
+import { evaluateStaticExpression } from '../discovery/index.ts'
+import {
+  resolveComponentProjectGeneratedDocsDir,
+  resolveComponentProjectGeneratedManifestPath,
+} from '../runtime/index.ts'
+
+type VideoResourceMetaRecord = {
+  packageName: string
+  exportName: string
+  metadata: {
+    resourceKind: 'scene' | 'transition' | 'theme'
+    name: string
+    description: string
+    sourceFile: string
+    pluginKey: string
+    tags: string[]
+    aspectRatio?: '9:16' | '16:9'
+    sceneType?: 'intro' | 'scene' | 'outro'
+    sceneFamily?: string
+    themePreset?: string
+    slots?: Array<string | {
+      name: string
+      description?: string
+      required?: boolean
+      accepts?: 'text' | 'image' | 'video' | 'component' | 'any'
+    }>
+    propsTypeName?: string
+    rootLayout?: 'absolute-fill'
+    transitionKind?: 'transition' | 'overlay'
+    supportedSceneFamilies?: string[]
+    cssVariables?: string[]
+  }
+}
+
+type VideoResourceMetaFile = {
+  videoResourceMeta?: {
+    packageFingerprint?: string
+    packages?: Array<{
+      packageName: string
+      packageVersion: string
+    }>
+    resources: VideoResourceMetaRecord[]
+  }
+}
+
+type GeneratedSkillDoc = {
+  filePath: string
+  contents: string
+}
+
+function stringifyFrontmatterList(items: readonly string[]): string {
+  return items.map((item) => `  - ${item}`).join('\n')
+}
+
+function stringifySlots(
+  slots: NonNullable<VideoResourceMetaRecord['metadata']['slots']>,
+): string {
+  if (slots.length === 0) {
+    return '[]'
+  }
+
+  return slots
+    .map((slot) => {
+      if (typeof slot === 'string') {
+        return `  - ${slot}`
+      }
+
+      const lines = [
+        `  - name: ${slot.name}`,
+        slot.description ? `    description: ${slot.description}` : undefined,
+        slot.required !== undefined ? `    required: ${slot.required}` : undefined,
+        slot.accepts ? `    accepts: ${slot.accepts}` : undefined,
+      ].filter(Boolean)
+
+      return lines.join('\n')
+    })
+    .join('\n')
+}
+
+function sanitizeFileName(name: string): string {
+  return name.replace(/[^a-zA-Z0-9._-]+/g, '-')
+}
+
+function getMetaFilePath(projectRoot: string): string {
+  return path.join(projectRoot, '.vibecuting', 'video-resource-meta.generated.ts')
+}
+
+async function readGeneratedVideoResourceMeta(projectRoot: string): Promise<NonNullable<VideoResourceMetaFile['videoResourceMeta']>> {
+  const metaFilePath = getMetaFilePath(projectRoot)
+  const sourceText = await fs.readFile(metaFilePath, 'utf8')
+  const sourceFile = ts.createSourceFile(metaFilePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement) || !statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+      continue
+    }
+
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || declaration.name.text !== 'videoResourceMeta') {
+        continue
+      }
+
+      if (!declaration.initializer) {
+        throw new Error(`${metaFilePath}: missing videoResourceMeta initializer`)
+      }
+
+      const videoResourceMeta = evaluateStaticExpression(declaration.initializer, metaFilePath) as VideoResourceMetaFile['videoResourceMeta']
+      if (!videoResourceMeta) {
+        throw new Error(`${metaFilePath}: missing videoResourceMeta export`)
+      }
+
+      return videoResourceMeta
+    }
+  }
+
+  throw new Error(`${metaFilePath}: missing videoResourceMeta export`)
+}
+
+function renderSceneMetadata(record: VideoResourceMetaRecord): string {
+  const { metadata } = record
+  const slots = metadata.slots ? stringifySlots(metadata.slots) : '[]'
+
+  return [
+    `- resourceKind: ${metadata.resourceKind}`,
+    `  aspectRatio: ${metadata.aspectRatio ?? ''}`,
+    `  sceneType: ${metadata.sceneType ?? ''}`,
+    `  sceneFamily: ${metadata.sceneFamily ?? ''}`,
+    `  themePreset: ${metadata.themePreset ?? ''}`,
+    `  rootLayout: ${metadata.rootLayout ?? ''}`,
+    `  propsTypeName: ${metadata.propsTypeName ?? ''}`,
+    `  slots:`,
+    slots,
+  ].join('\n')
+}
+
+function renderTransitionMetadata(record: VideoResourceMetaRecord): string {
+  const { metadata } = record
+
+  return [
+    `- resourceKind: ${metadata.resourceKind}`,
+    `  transitionKind: ${metadata.transitionKind ?? ''}`,
+  ].join('\n')
+}
+
+function renderThemeMetadata(record: VideoResourceMetaRecord): string {
+  const { metadata } = record
+  const supportedSceneFamilies = metadata.supportedSceneFamilies ?? []
+  const cssVariables = metadata.cssVariables ?? []
+
+  return [
+    `- resourceKind: ${metadata.resourceKind}`,
+    `  supportedSceneFamilies:`,
+    supportedSceneFamilies.length > 0 ? stringifyFrontmatterList(supportedSceneFamilies) : '  []',
+    `  cssVariables:`,
+    cssVariables.length > 0 ? stringifyFrontmatterList(cssVariables) : '  []',
+  ].join('\n')
+}
+
+function buildDocContents(record: VideoResourceMetaRecord): string {
+  const { metadata, exportName } = record
+  const tags = metadata.tags ?? []
+  const bodyMetadata =
+    metadata.resourceKind === 'scene'
+      ? renderSceneMetadata(record)
+      : metadata.resourceKind === 'transition'
+        ? renderTransitionMetadata(record)
+        : renderThemeMetadata(record)
+
+  return [
+    '---',
+    `name: ${metadata.name}`,
+    `resourceKind: ${metadata.resourceKind}`,
+    `description: ${metadata.description}`,
+    `sourceFile: ${metadata.sourceFile}`,
+    `pluginKey: ${metadata.pluginKey}`,
+    `tags:`,
+    tags.length > 0 ? stringifyFrontmatterList(tags) : '  []',
+    '---',
+    '',
+    `# ${exportName}`,
+    '',
+    metadata.description,
+    '',
+    '## 元数据',
+    '',
+    `- 资源类型: \`${metadata.resourceKind}\``,
+    `- 源文件: \`${metadata.sourceFile}\``,
+    `- 插件键: \`${metadata.pluginKey}\``,
+    `- 标签: ${tags.length > 0 ? tags.map((tag) => `\`${tag}\``).join(', ') : '[]'}`,
+    '',
+    bodyMetadata,
+    '',
+  ].join('\n')
+}
+
+async function writeTextFile(filePath: string, contents: string): Promise<void> {
+  await fs.mkdir(path.dirname(filePath), { recursive: true })
+  const tempPath = `${filePath}.tmp`
+  await fs.writeFile(tempPath, `${contents}\n`, 'utf8')
+  await fs.rename(tempPath, filePath)
+}
+
+async function readOptionalFile(filePath: string): Promise<string | undefined> {
+  try {
+    return await fs.readFile(filePath, 'utf8')
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return undefined
+    }
+
+    throw error
+  }
+}
+
+export async function updateComponentSkills(
+  projectRoot: string,
+  checkOnly = false,
+): Promise<void> {
+  const videoResourceMeta = await readGeneratedVideoResourceMeta(projectRoot)
+  const docsDir = resolveComponentProjectGeneratedDocsDir(projectRoot)
+  const manifestPath = resolveComponentProjectGeneratedManifestPath(projectRoot)
+  const resources = [...videoResourceMeta.resources].sort((left, right) => {
+    return (
+      left.metadata.resourceKind.localeCompare(right.metadata.resourceKind) ||
+      left.metadata.pluginKey.localeCompare(right.metadata.pluginKey) ||
+      left.exportName.localeCompare(right.exportName)
+    )
+  })
+
+  const generatedDocs: GeneratedSkillDoc[] = resources.map((record) => {
+    const filePath = path.join(docsDir, `${sanitizeFileName(record.exportName)}.md`)
+    return { filePath, contents: buildDocContents(record) }
+  })
+
+  const manifestContents = JSON.stringify(
+    {
+      projectRoot,
+      docsDir,
+      sourceMetaFile: getMetaFilePath(projectRoot),
+      packageFingerprint: videoResourceMeta.packageFingerprint ?? null,
+      files: generatedDocs.map((doc) => doc.filePath),
+      resources: resources.map((resource) => ({
+        packageName: resource.packageName,
+        exportName: resource.exportName,
+        resourceKind: resource.metadata.resourceKind,
+        pluginKey: resource.metadata.pluginKey,
+      })),
+    },
+    null,
+    2,
+  )
+
+  if (checkOnly) {
+    const currentManifest = await readOptionalFile(manifestPath)
+    if (currentManifest?.trimEnd() !== `${manifestContents}\n`.trimEnd()) {
+      throw new Error('Generated component skill manifest is stale. Run pnpm run update-component-skills')
+    }
+
+    for (const doc of generatedDocs) {
+      const currentDoc = await readOptionalFile(doc.filePath)
+      if (currentDoc?.trimEnd() !== doc.contents.trimEnd()) {
+        throw new Error(`Generated component skill doc is stale: ${doc.filePath}`)
+      }
+    }
+
+    return
+  }
+
+  await writeTextFile(manifestPath, manifestContents)
+  await fs.mkdir(docsDir, { recursive: true })
+
+  const desiredFiles = new Set(generatedDocs.map((doc) => doc.filePath))
+
+  await Promise.all(
+    generatedDocs.map((doc) => writeTextFile(doc.filePath, doc.contents)),
+  )
+
+  const existingEntries = await fs.readdir(docsDir, { withFileTypes: true })
+  await Promise.all(
+    existingEntries
+      .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+      .map(async (entry) => {
+        const filePath = path.join(docsDir, entry.name)
+        if (desiredFiles.has(filePath)) {
+          return
+        }
+
+        await fs.unlink(filePath)
+      }),
+  )
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const checkOnly = process.argv.includes('--check')
+  const cwd = process.cwd()
+
+  updateComponentSkills(cwd, checkOnly).catch((error: unknown) => {
+    const message = error instanceof Error ? error.message : String(error)
+    console.error(message)
+    process.exitCode = 1
+  })
+}

package/src/resources/resource-descriptors.ts

@@ -0,0 +1,47 @@
+import { createRequire } from 'node:module'
+import type {
+  ScenePluginMetadata,
+  ThemePluginMetadata,
+  TransitionPluginMetadata,
+  VideoResourceDescriptor,
+  VideoResourceMetadata,
+} from './video-resource.ts'
+import {
+  ScenePluginMetadataSchema,
+  ThemePluginMetadataSchema,
+  TransitionPluginMetadataSchema,
+} from './video-resource.ts'
+
+const require = createRequire(import.meta.url)
+const videoResourceDescriptorDefinitionRows = require('./video-resource-descriptors.json')
+
+export const videoResourceDescriptorDefinitions = videoResourceDescriptorDefinitionRows
+
+export type VideoResourceDescriptorDefinition = (typeof videoResourceDescriptorDefinitions)[number]
+
+export const sceneResourceDescriptor: VideoResourceDescriptor<ScenePluginMetadata> = {
+  kind: 'scene',
+  annotationName: 'VideoComponent',
+  metadataFactoryName: 'defineScenePluginMetadata',
+  schema: ScenePluginMetadataSchema,
+}
+
+export const transitionResourceDescriptor: VideoResourceDescriptor<TransitionPluginMetadata> = {
+  kind: 'transition',
+  annotationName: 'TransitionComponent',
+  metadataFactoryName: 'defineTransitionPluginMetadata',
+  schema: TransitionPluginMetadataSchema,
+}
+
+export const themeResourceDescriptor: VideoResourceDescriptor<ThemePluginMetadata> = {
+  kind: 'theme',
+  annotationName: 'ThemeComponent',
+  metadataFactoryName: 'defineThemePluginMetadata',
+  schema: ThemePluginMetadataSchema,
+}
+
+export const videoResourceDescriptors = [
+  sceneResourceDescriptor,
+  transitionResourceDescriptor,
+  themeResourceDescriptor,
+] as const satisfies readonly VideoResourceDescriptor<VideoResourceMetadata>[]

package/src/resources/video-resource-descriptors.json

@@ -0,0 +1,17 @@
+[
+  {
+    "kind": "scene",
+    "annotationName": "VideoComponent",
+    "metadataFactoryName": "defineScenePluginMetadata"
+  },
+  {
+    "kind": "transition",
+    "annotationName": "TransitionComponent",
+    "metadataFactoryName": "defineTransitionPluginMetadata"
+  },
+  {
+    "kind": "theme",
+    "annotationName": "ThemeComponent",
+    "metadataFactoryName": "defineThemePluginMetadata"
+  }
+]

package/src/resources/video-resource.ts

@@ -0,0 +1,143 @@
+import 'reflect-metadata'
+
+import { z } from 'zod'
+
+export const VideoResourceKindSchema = z.enum(['scene', 'transition', 'theme'])
+
+export type VideoResourceKind = z.infer<typeof VideoResourceKindSchema>
+
+export const BaseVideoResourceMetadataSchema = z.object({
+  resourceKind: VideoResourceKindSchema,
+  name: z.string().min(1),
+  description: z.string().min(1),
+  sourceFile: z.string().min(1),
+  pluginKey: z.string().min(1),
+  tags: z.array(z.string().min(1)).default([]),
+})
+
+export const SceneSlotHintSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1).optional(),
+  required: z.boolean().optional(),
+  accepts: z.enum(['text', 'image', 'video', 'component', 'any']).optional(),
+})
+
+export const SceneSlotsSchema = z.union([
+  z.array(z.string().min(1)),
+  z.array(SceneSlotHintSchema),
+])
+
+const SceneFamilySchema = z.enum(['slide', 'canvas-2d', 'game-2d', 'three-3d', 'custom'])
+
+export const ScenePluginMetadataSchema = BaseVideoResourceMetadataSchema.extend({
+  resourceKind: z.literal('scene'),
+  aspectRatio: z.enum(['9:16', '16:9']),
+  sceneType: z.enum(['intro', 'scene', 'outro']).optional(),
+  sceneFamily: SceneFamilySchema.default('custom'),
+  themePreset: z.string().min(1).optional(),
+  slots: SceneSlotsSchema.optional(),
+  propsTypeName: z.string().min(1).optional(),
+  rootLayout: z.literal('absolute-fill').default('absolute-fill'),
+})
+
+export const TransitionPluginMetadataSchema = BaseVideoResourceMetadataSchema.extend({
+  resourceKind: z.literal('transition'),
+  transitionKind: z.enum(['transition', 'overlay']),
+})
+
+export const ThemePluginMetadataSchema = BaseVideoResourceMetadataSchema.extend({
+  resourceKind: z.literal('theme'),
+  supportedSceneFamilies: z.array(SceneFamilySchema).default([]),
+  cssVariables: z.array(z.string().regex(/^--scene-/)).default([]),
+})
+
+export const VideoResourceMetadataSchema = z.discriminatedUnion('resourceKind', [
+  ScenePluginMetadataSchema,
+  TransitionPluginMetadataSchema,
+  ThemePluginMetadataSchema,
+])
+
+export type ScenePluginMetadata = z.infer<typeof ScenePluginMetadataSchema>
+export type SceneSlotHint = z.infer<typeof SceneSlotHintSchema>
+export type TransitionPluginMetadata = z.infer<typeof TransitionPluginMetadataSchema>
+export type ThemePluginMetadata = z.infer<typeof ThemePluginMetadataSchema>
+export type VideoResourceMetadata = z.infer<typeof VideoResourceMetadataSchema>
+
+export const VIDEO_RESOURCE_METADATA_KEY = Symbol.for(
+  '@vibecuting/component-project-helper/video-resource-metadata',
+)
+
+export type VideoResourceDescriptor<TMetadata extends VideoResourceMetadata> = {
+  kind: TMetadata['resourceKind']
+  annotationName: string
+  metadataFactoryName: string
+  schema: z.ZodType<TMetadata>
+}
+
+export type VideoResourceAnnotation<TMetadata extends VideoResourceMetadata> = {
+  defineMetadata(input: TMetadata): TMetadata
+  annotate(metadata: TMetadata): <T extends object>(target: T) => T
+  getMetadata(target: unknown): TMetadata | undefined
+}
+
+export function createVideoResourceAnnotation<TMetadata extends VideoResourceMetadata>(
+  descriptor: VideoResourceDescriptor<TMetadata>,
+): VideoResourceAnnotation<TMetadata> {
+  return {
+    defineMetadata(input) {
+      return descriptor.schema.parse(input)
+    },
+    annotate(metadata) {
+      const normalized = descriptor.schema.parse(metadata)
+
+      return function annotateTarget<T extends object>(target: T): T {
+        Reflect.defineMetadata(VIDEO_RESOURCE_METADATA_KEY, normalized, target)
+        return target
+      }
+    },
+    getMetadata(target) {
+      if (!target || (typeof target !== 'object' && typeof target !== 'function')) {
+        return undefined
+      }
+
+      const metadata = Reflect.getMetadata(VIDEO_RESOURCE_METADATA_KEY, target)
+      const parsed = descriptor.schema.safeParse(metadata)
+      return parsed.success ? parsed.data : undefined
+    },
+  }
+}
+
+export function getVideoResourceMetadata<TMetadata extends VideoResourceMetadata>(
+  target: unknown,
+  expectedKind?: TMetadata['resourceKind'],
+): TMetadata | undefined {
+  if (!target || (typeof target !== 'object' && typeof target !== 'function')) {
+    return undefined
+  }
+
+  const metadata = Reflect.getMetadata(VIDEO_RESOURCE_METADATA_KEY, target)
+  const parsed = VideoResourceMetadataSchema.safeParse(metadata)
+  if (!parsed.success) {
+    return undefined
+  }
+
+  if (expectedKind && parsed.data.resourceKind !== expectedKind) {
+    return undefined
+  }
+
+  return parsed.data as TMetadata
+}
+
+export function defineScenePluginMetadata(input: ScenePluginMetadata): ScenePluginMetadata {
+  return ScenePluginMetadataSchema.parse(input)
+}
+
+export function defineTransitionPluginMetadata(
+  input: TransitionPluginMetadata,
+): TransitionPluginMetadata {
+  return TransitionPluginMetadataSchema.parse(input)
+}
+
+export function defineThemePluginMetadata(input: ThemePluginMetadata): ThemePluginMetadata {
+  return ThemePluginMetadataSchema.parse(input)
+}

package/src/schemas/index.ts

@@ -1,6 +1,25 @@
 import { z } from 'zod'
 
-export const ComponentProjectComponentMetadataSchema = z.object({
+export {
+  BaseVideoResourceMetadataSchema,
+  ScenePluginMetadataSchema,
+  SceneSlotHintSchema,
+  SceneSlotsSchema,
+  ThemePluginMetadataSchema,
+  TransitionPluginMetadataSchema,
+  VideoResourceKindSchema,
+  VideoResourceMetadataSchema,
+} from '../resources/video-resource.ts'
+export type {
+  ScenePluginMetadata,
+  SceneSlotHint,
+  ThemePluginMetadata,
+  TransitionPluginMetadata,
+  VideoResourceKind,
+  VideoResourceMetadata,
+} from '../resources/video-resource.ts'
+
+const ComponentProjectComponentMetadataInputSchema = z.object({
   name: z.string().min(1),
   description: z.string().min(1),
   sourceFile: z.string().min(1),
@@ -10,6 +29,9 @@ export const ComponentProjectComponentMetadataSchema = z.object({
   propsTypeName: z.string().min(1).optional(),
 })
 
+export const ComponentProjectComponentMetadataSchema =
+  ComponentProjectComponentMetadataInputSchema
+
 export const ComponentProjectGeneratedManifestSchema = z.object({
   projectRoot: z.string().min(1),
   generatedAt: z.string().min(1),
@@ -18,7 +40,7 @@ export const ComponentProjectGeneratedManifestSchema = z.object({
 })
 
 export type ComponentProjectComponentMetadata = z.infer<
-  typeof ComponentProjectComponentMetadataSchema
+  typeof ComponentProjectComponentMetadataInputSchema
 >
 export type ComponentProjectGeneratedManifest = z.infer<
   typeof ComponentProjectGeneratedManifestSchema

package/scripts/postinstall.mjs

@@ -1,112 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-import { discoverComponentProjectComponents } from './discover-components.mjs'
-import { ensureComponentProjectSkillsScript } from './package-json.mjs'
-import {
-  resolveComponentProjectGeneratedDocsDir,
-  resolveComponentProjectGeneratedManifestPath,
-  resolveComponentProjectInstallRoot,
-} from './runtime-root.mjs'
-import { renderComponentProjectMarkdown } from './render-markdown.mjs'
-import { ComponentProjectGeneratedManifestSchema } from './schemas.mjs'
-
-const supportsColor =
-  Boolean(process.stdout.isTTY) && process.env.NO_COLOR !== '1' && process.env.CI !== 'true'
-
-const color = {
-  cyan: (value) => (supportsColor ? `\u001b[36m${value}\u001b[0m` : value),
-  green: (value) => (supportsColor ? `\u001b[32m${value}\u001b[0m` : value),
-  yellow: (value) => (supportsColor ? `\u001b[33m${value}\u001b[0m` : value),
-  dim: (value) => (supportsColor ? `\u001b[2m${value}\u001b[0m` : value),
-}
-
-async function ensureDirectory(dir) {
-  await fs.mkdir(dir, { recursive: true })
-}
-
-async function removeStaleGeneratedFiles(manifestPath, nextFiles) {
-  try {
-    const previous = ComponentProjectGeneratedManifestSchema.parse(
-      JSON.parse(await fs.readFile(manifestPath, 'utf8')),
-    )
-    const staleFiles = previous.files.filter((filePath) => !nextFiles.includes(filePath))
-    await Promise.all(staleFiles.map((filePath) => fs.rm(filePath, { force: true })))
-  } catch (error) {
-    if (error?.code !== 'ENOENT') {
-      throw error
-    }
-  }
-}
-
-export async function runComponentProjectPostinstall(projectRoot = resolveComponentProjectInstallRoot()) {
-  const docsDir = resolveComponentProjectGeneratedDocsDir(projectRoot)
-  const manifestPath = resolveComponentProjectGeneratedManifestPath(projectRoot)
-  const components = await discoverComponentProjectComponents(projectRoot)
-
-  console.log(color.cyan('[component-project-helper] postinstall start'))
-  console.log(color.dim(`[component-project-helper] project root: ${projectRoot}`))
-  console.log(color.dim(`[component-project-helper] docs dir: ${docsDir}`))
-  console.log(color.dim(`[component-project-helper] manifest path: ${manifestPath}`))
-  console.log(
-    color.green(
-      `[component-project-helper] discovered ${components.length} component(s): ${
-      components.map((component) => component.name).join(', ') || '(none)'
-      }`,
-    ),
-  )
-
-  await ensureDirectory(docsDir)
-
-  const files = []
-  for (const component of components) {
-    const filePath = path.join(docsDir, `${component.name}.md`)
-    await fs.writeFile(filePath, renderComponentProjectMarkdown(component), 'utf8')
-    files.push(filePath)
-    console.log(
-      color.green(
-        `[component-project-helper] wrote ${path.relative(projectRoot, filePath)} <- ${component.sourceFile}`,
-      ),
-    )
-  }
-
-  console.log(
-    color.yellow(
-      `[component-project-helper] cleaning stale docs relative to manifest ${path.relative(
-      projectRoot,
-      manifestPath,
-      )}`,
-    ),
-  )
-  await removeStaleGeneratedFiles(manifestPath, files)
-  await ensureComponentProjectSkillsScript(projectRoot)
-  console.log(color.green('[component-project-helper] ensured update-component-skills script'))
-  console.log('[component-project-helper] ensured stale docs cleaned')
-
-  const manifest = ComponentProjectGeneratedManifestSchema.parse({
-    projectRoot,
-    generatedAt: new Date().toISOString(),
-    docsDir,
-    files,
-  })
-  await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8')
-  console.log(
-    color.cyan(
-      `[component-project-helper] postinstall complete, manifest files: ${files.length}`,
-    ),
-  )
-}
-
-async function isDirectRun() {
-  if (!process.argv[1]) {
-    return false
-  }
-
-  const entryPath = await fs.realpath(process.argv[1])
-  const currentPath = await fs.realpath(new URL(import.meta.url).pathname)
-  return entryPath === currentPath
-}
-
-if (await isDirectRun()) {
-  await runComponentProjectPostinstall()
-}