spec-agent 2.0.5 → 2.0.6

package/src/commands/scan.ts

@@ -1,4 +1,5 @@
 import * as path from 'path';
+import * as fs from 'fs-extra';
 import { Command } from 'commander';
 import { Logger } from '../utils/logger';
 import { 
@@ -8,8 +9,7 @@ import {
   formatSize, 
   parseSize,
   findFiles,
-  writeJson,
-  readFileContent
+  writeJson
 } from '../utils/file';
 import { parseDocument, analyzeBase64Images } from '../services/document-parser';
 import { 
@@ -19,7 +19,7 @@ import {
   getLLMConfigForPurpose,
   validateLLMConfig 
 } from '../services/llm';
-import { Manifest, Chunk } from '../types';
+import { Manifest, Chunk, PrototypeAsset } from '../types';
 
 interface ScanOptions {
   input?: string;
@@ -53,6 +53,16 @@ const SCAN_EXIT_CODE = {
   RUNTIME_ERROR: 10,
 } as const;
 
+interface PrototypeAssetPending {
+  id: string;
+  sourceFile: string;
+  alt: string;
+  mimeType: string;
+  estimatedSize: number;
+  dataUri: string;
+  summary?: string;
+}
+
 export async function scanCommand(options: ScanOptions, command: Command): Promise<void> {
   const logger = new Logger();
   
@@ -118,6 +128,7 @@ export async function scanCommand(options: ScanOptions, command: Command): Promi
     let llmChunkingFallbackFiles = 0;
     let imageAssetsDetected = 0;
     let imageAssetsDescribed = 0;
+    const pendingPrototypeAssets: PrototypeAssetPending[] = [];
     if (useLLMChunking && llmConfig) {
       // LLM chunking is enabled by default; fail fast so we don't silently degrade
       // to regex-only behavior on complex documents.
@@ -129,23 +140,44 @@ export async function scanCommand(options: ScanOptions, command: Command): Promi
       }
     }
 
-    for (const filePath of inputFiles) {
+    for (let fileIdx = 0; fileIdx < inputFiles.length; fileIdx++) {
+      const filePath = inputFiles[fileIdx];
       logger.info(`Parsing ${path.basename(filePath)}...`);
       
       try {
         const parsed = await parseDocument(filePath);
         let contentForChunking = parsed.content;
-        imageAssetsDetected += parsed.images?.length || 0;
+        const parsedImages = (parsed.images || []).map(image => ({
+          ...image,
+          id: scopeImageId(fileIdx, image.id),
+        }));
+        const idMapping = new Map<string, string>();
+        for (let i = 0; i < (parsed.images || []).length; i++) {
+          idMapping.set(parsed.images![i].id, parsedImages[i].id);
+        }
+        contentForChunking = replaceImageIds(contentForChunking, idMapping);
+        imageAssetsDetected += parsedImages.length;
         let imageSummaries: Record<string, string> = {};
 
-        if (parsed.images && parsed.images.length > 0) {
-          logger.info(`  检测到 ${parsed.images.length} 张嵌入图片`);
+        if (parsedImages.length > 0) {
+          logger.info(`  检测到 ${parsedImages.length} 张嵌入图片`);
           if (llmConfig && llmConfig.apiKey) {
-            imageSummaries = await describeEmbeddedImages(parsed.images, llmConfig, logger);
+            imageSummaries = await describeEmbeddedImages(parsedImages, llmConfig, logger);
             imageAssetsDescribed += Object.keys(imageSummaries).length;
           } else {
             logger.warn('  未配置 LLM，图片仅保留占位信息，不含语义摘要');
           }
+          for (const image of parsedImages) {
+            pendingPrototypeAssets.push({
+              id: image.id,
+              sourceFile: filePath,
+              alt: image.alt,
+              mimeType: image.mimeType,
+              estimatedSize: image.estimatedSize,
+              dataUri: image.dataUri,
+              summary: imageSummaries[image.id],
+            });
+          }
         }
         
         // Log if base64 images were found and removed
@@ -235,7 +267,9 @@ export async function scanCommand(options: ScanOptions, command: Command): Promi
     // Prepare chunks directory
     const outputDir = path.dirname(path.resolve(options.output));
     const chunksDir = path.join(outputDir, 'chunks');
+    const prototypesDir = path.join(outputDir, 'prototypes');
     await ensureDir(chunksDir);
+    await ensureDir(prototypesDir);
 
     // Write chunks to files
     const chunks: Chunk[] = [];
@@ -244,7 +278,7 @@ export async function scanCommand(options: ScanOptions, command: Command): Promi
       const chunkFileName = `chunk_${i}.txt`;
       const chunkFilePath = path.join(chunksDir, chunkFileName);
       
-      await require('fs-extra').writeFile(chunkFilePath, rawChunk.content, 'utf-8');
+      await fs.writeFile(chunkFilePath, rawChunk.content, 'utf-8');
       
       chunks.push({
         id: i,
@@ -254,6 +288,13 @@ export async function scanCommand(options: ScanOptions, command: Command): Promi
       });
     }
 
+    const prototypeAssets = await writePrototypeAssets({
+      outputDir,
+      prototypesDir,
+      rawChunks,
+      pendingAssets: pendingPrototypeAssets,
+    });
+
     // Create manifest
     const manifest: Manifest = {
       version: '1.0.0',
@@ -262,6 +303,7 @@ export async function scanCommand(options: ScanOptions, command: Command): Promi
       totalSize: totalSize,
       chunkSize: chunkSizeBytes,
       chunks: chunks,
+      prototypeAssets,
     };
 
     // Write manifest
@@ -270,6 +312,9 @@ export async function scanCommand(options: ScanOptions, command: Command): Promi
     await writeJson(outputPath, manifest);
 
     logger.success(`Manifest created: ${outputPath}`);
+    if (prototypeAssets.length > 0) {
+      logger.info(`Prototype index: ${path.join(outputDir, 'prototype_index.json')}`);
+    }
     logger.json({
       status: 'success',
       totalFiles: inputFiles.length,
@@ -281,6 +326,7 @@ export async function scanCommand(options: ScanOptions, command: Command): Promi
       llmChunkingFallbackFiles,
       imageAssetsDetected,
       imageAssetsDescribed,
+      prototypeAssets: prototypeAssets.length,
       manifestPath: outputPath,
     });
 
@@ -527,7 +573,7 @@ function appendImageSummariesToChunk(content: string, imageSummaries: Record<str
     return content;
   }
 
-  const idMatches = content.match(/图片引用\s+((?:IMG|PDFIMG)\d{4})/g) || [];
+  const idMatches = content.match(/图片引用\s+([A-Z0-9_]+)/g) || [];
   const imageIds = Array.from(new Set(idMatches.map(item => item.replace(/.*\s+/, '').trim())));
   if (imageIds.length === 0) {
     return content;
@@ -548,6 +594,113 @@ function appendImageSummariesToChunk(content: string, imageSummaries: Record<str
   return `${content}\n\n### 图片语义补充\n${summaryLines.join('\n')}`;
 }
 
+async function writePrototypeAssets(input: {
+  outputDir: string;
+  prototypesDir: string;
+  rawChunks: Array<{ content: string; sourceFiles: string[]; title?: string }>;
+  pendingAssets: PrototypeAssetPending[];
+}): Promise<PrototypeAsset[]> {
+  const { outputDir, prototypesDir, rawChunks, pendingAssets } = input;
+  if (pendingAssets.length === 0) {
+    return [];
+  }
+
+  const prototypeAssets: PrototypeAsset[] = [];
+  for (const asset of pendingAssets) {
+    const ext = extFromMimeType(asset.mimeType);
+    const fileName = `${asset.id}.${ext}`;
+    const absolutePath = path.join(prototypesDir, fileName);
+    const written = await writeDataUriToFile(asset.dataUri, absolutePath);
+    if (!written) {
+      continue;
+    }
+    const sourceChunks = collectSourceChunks(rawChunks, asset.id);
+    prototypeAssets.push({
+      id: asset.id,
+      sourceFile: asset.sourceFile,
+      alt: asset.alt,
+      mimeType: asset.mimeType,
+      estimatedSize: asset.estimatedSize,
+      path: path.join('prototypes', fileName).replace(/\\/g, '/'),
+      summary: asset.summary,
+      sourceChunks,
+    });
+  }
+
+  const indexJsonPath = path.join(outputDir, 'prototype_index.json');
+  await writeJson(indexJsonPath, {
+    version: '1.0.0',
+    createdAt: new Date().toISOString(),
+    total: prototypeAssets.length,
+    assets: prototypeAssets,
+  });
+
+  const indexMarkdownPath = path.join(outputDir, 'prototype_index.md');
+  const lines: string[] = [
+    '# Prototype Index',
+    '',
+    `- Total: ${prototypeAssets.length}`,
+    '',
+    '| ID | Path | Source File | Chunks | Summary |',
+    '| --- | --- | --- | --- | --- |',
+  ];
+  for (const asset of prototypeAssets) {
+    lines.push(
+      `| ${asset.id} | \`${asset.path}\` | \`${path.basename(asset.sourceFile)}\` | ${asset.sourceChunks.join(', ') || '-'} | ${(asset.summary || '').replace(/\|/g, '\\|')} |`
+    );
+  }
+  await fs.writeFile(indexMarkdownPath, `${lines.join('\n')}\n`, 'utf-8');
+
+  return prototypeAssets;
+}
+
+function collectSourceChunks(
+  rawChunks: Array<{ content: string; sourceFiles: string[]; title?: string }>,
+  imageId: string
+): number[] {
+  const results: number[] = [];
+  for (let i = 0; i < rawChunks.length; i++) {
+    if (rawChunks[i].content.includes(imageId)) {
+      results.push(i);
+    }
+  }
+  return results;
+}
+
+function scopeImageId(fileIdx: number, imageId: string): string {
+  return `F${String(fileIdx + 1).padStart(3, '0')}_${imageId}`;
+}
+
+function replaceImageIds(content: string, idMapping: Map<string, string>): string {
+  let next = content;
+  for (const [fromId, toId] of idMapping.entries()) {
+    next = next.replace(new RegExp(`\\b${escapeRegExp(fromId)}\\b`, 'g'), toId);
+  }
+  return next;
+}
+
+function escapeRegExp(input: string): string {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function extFromMimeType(mimeType: string): string {
+  if (mimeType.includes('png')) return 'png';
+  if (mimeType.includes('jpeg') || mimeType.includes('jpg')) return 'jpg';
+  if (mimeType.includes('webp')) return 'webp';
+  if (mimeType.includes('gif')) return 'gif';
+  return 'img';
+}
+
+async function writeDataUriToFile(dataUri: string, filePath: string): Promise<boolean> {
+  const match = dataUri.match(/^data:image\/[a-zA-Z0-9.+-]+;base64,([A-Za-z0-9+/=]+)$/);
+  if (!match) {
+    return false;
+  }
+  const buffer = Buffer.from(match[1], 'base64');
+  await fs.writeFile(filePath, buffer);
+  return true;
+}
+
 function readStdin(): Promise<string> {
   return new Promise((resolve) => {
     let data = '';

package/src/types.ts

@@ -10,6 +10,17 @@ export interface Chunk {
   endLine?: number;
 }
 
+export interface PrototypeAsset {
+  id: string;
+  sourceFile: string;
+  alt: string;
+  mimeType: string;
+  estimatedSize: number;
+  path: string;
+  summary?: string;
+  sourceChunks: number[];
+}
+
 export interface Manifest {
   version: string;
   createdAt: string;
@@ -17,6 +28,7 @@ export interface Manifest {
   totalSize: number;
   chunkSize: number;
   chunks: Chunk[];
+  prototypeAssets?: PrototypeAsset[];
 }
 
 export interface Feature {