fix: honor in-app exclude/delete after export path normalization

Export rebuild strips the project root from file paths, but UI exclude
and remove state still used root-prefixed paths, so files like .env
reappeared on copy/save. Align both sides before merging manual state.

Author: yeahhe365

src/services/exportBuilder.test.ts

@@ -271,6 +271,69 @@ describe('buildExportOutput', () => {
     expect(output).not.toContain('"src/removed.ts"');
   });
 
+  it('honors in-app exclude/delete when UI paths still include the project root prefix', async () => {
+    // processFiles stores webkitRelativePath as-is (e.g. demo/.env). Export then strips the
+    // root for packed output. Manual exclude/delete must still match after that strip.
+    const files = [
+      createFile('demo/.env', 'SECRET=should-not-export\n'),
+      createFile('demo/src/app.ts', 'export const answer = 42;\n'),
+      createFile('demo/src/gone.ts', 'export const gone = true;\n'),
+    ];
+
+    const rootPrefixedCurrentData: ProcessedFiles = {
+      rootName: 'demo',
+      structureString: 'demo\n├── .env\n└── src\n    ├── app.ts\n    └── gone.ts\n',
+      treeData: [],
+      fileContents: [
+        {
+          path: 'demo/.env',
+          content: 'SECRET=should-not-export\n',
+          originalContent: 'SECRET=should-not-export\n',
+          language: 'properties',
+          stats: { lines: 1, chars: 25, estimatedTokens: 4 },
+          excluded: true,
+        },
+        {
+          path: 'demo/src/app.ts',
+          content: 'export const answer = 42;\n',
+          originalContent: 'export const answer = 42;\n',
+          language: 'typescript',
+          stats: { lines: 1, chars: 26, estimatedTokens: 6 },
+        },
+      ],
+      analysisSummary: {
+        totalEstimatedTokens: 10,
+        securityFindingCount: 0,
+        scannedFileCount: 2,
+      },
+      securityFindings: [],
+      exportMetadata: {
+        usesDefaultIgnorePatterns: true,
+        usesGitignorePatterns: false,
+        sortsByGitChangeCount: false,
+      },
+      // User deleted gone.ts from the explorer; path matches tree/processFiles form.
+      removedPaths: ['demo/src/gone.ts'],
+    };
+
+    const output = await buildExportOutput({
+      currentData: rootPrefixedCurrentData,
+      rawFiles: files,
+      emptyDirectoryPaths: [],
+      exportOptions: createExportOptions({ format: 'json', useGitignore: false }),
+      extractContent: true,
+      maxCharsThreshold: 100000,
+      progressCallback: vi.fn(),
+    });
+
+    expect(output).toContain('"src/app.ts"');
+    expect(output).toContain('export const answer = 42;');
+    expect(output).not.toContain('SECRET=should-not-export');
+    expect(output).not.toContain('".env"');
+    expect(output).not.toContain('"src/gone.ts"');
+    expect(output).not.toContain('export const gone = true');
+  });
+
   it('does not emit edited changes sections', async () => {
     const files = [createFile('demo/src/app.ts', CURRENT_DATA.fileContents[0].originalContent ?? '')];
 

src/services/exportData.ts

@@ -119,15 +119,40 @@ function buildTree(
   };
 }
 
+/**
+ * processFiles stores paths with the project root segment (e.g. `demo/.env`).
+ * Export rebuild strips that root so packed output uses repo-relative paths (`.env`).
+ * Manual UI state (exclude / delete / edits) still carries the original paths, so
+ * matching must strip the same root prefix before comparing.
+ */
+function stripRootPrefix(path: string, rootName: string): string {
+  if (!rootName) {
+    return path;
+  }
+
+  const prefix = `${rootName}/`;
+  return path.startsWith(prefix) ? path.slice(prefix.length) : path;
+}
+
 function applyManualState(exportData: ProcessedFiles, currentData: ProcessedFiles): ProcessedFiles {
-  const currentByPath = new Map(currentData.fileContents.map((file) => [file.path, file]));
-  const removedPaths = new Set(currentData.removedPaths ?? []);
+  const rootName = currentData.rootName || exportData.rootName;
+  const currentByPath = new Map(
+    currentData.fileContents.map((file) => {
+      const path = stripRootPrefix(file.path, rootName);
+      return [path, { ...file, path }] as const;
+    })
+  );
+  const removedPaths = new Set((currentData.removedPaths ?? []).map((path) => stripRootPrefix(path, rootName)));
 
   const mergedFiles = exportData.fileContents
     .filter((file) => !removedPaths.has(file.path))
     .map((file) => {
       const current = currentByPath.get(file.path);
-      return current ? { ...file, ...current } : file;
+      if (!current) {
+        return file;
+      }
+      // Keep the export-normalized path; never reintroduce the root prefix from UI state.
+      return { ...file, ...current, path: file.path };
     });
   mergedFiles.sort((a, b) => compareFilePaths(a.path, b.path));
 
@@ -148,18 +173,13 @@ function applyManualState(exportData: ProcessedFiles, currentData: ProcessedFile
 }
 
 function normalizeExportPaths(data: ProcessedFiles): ProcessedFiles {
-  const stripRootPrefix = (path: string) => {
-    const prefix = `${data.rootName}/`;
-    return path.startsWith(prefix) ? path.slice(prefix.length) : path;
-  };
-
   return {
     ...data,
     fileContents: data.fileContents.map((file) => ({
       ...file,
-      path: stripRootPrefix(file.path),
+      path: stripRootPrefix(file.path, data.rootName),
     })),
-    emptyDirectoryPaths: (data.emptyDirectoryPaths ?? []).map(stripRootPrefix),
+    emptyDirectoryPaths: (data.emptyDirectoryPaths ?? []).map((path) => stripRootPrefix(path, data.rootName)),
   };
 }