sln2csproj 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 bnggbn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,273 @@
+# sln2csproj
+
+Generate a fake `.csproj` for legacy ASP.NET WebSite projects found in a `.sln`, so VS Code / C# tooling can provide IntelliSense without converting the original solution.
+
+## What It Does
+
+This tool is for old Visual Studio WebSite solutions that do not have a real `.csproj` for the website itself.
+
+It reads the `.sln`, finds the Website project, and generates:
+
+- a fake website `.csproj`
+- a fake `.sln` that points the Website entry to that fake `.csproj`
+- reference hint paths for project DLLs and DLLs already present in the website `Bin` folder
+
+The original solution is not modified.
+
+## Typical Use Case
+
+You have an old VS2005/VS2008/VS2010-era ASP.NET WebSite project.
+
+- Visual Studio can still open it
+- VS Code / Roslyn / C# extension cannot resolve the website correctly
+- you want IntelliSense only
+- you do not want to upgrade or convert the project
+
+## Install
+
+### From npm
+
+```bash
+npm install -g sln2csproj
+```
+
+Then run:
+
+```bash
+sln2csproj path/to/Your.sln
+```
+
+Or without global install:
+
+```bash
+npx sln2csproj path/to/Your.sln
+```
+
+### Local Development
+
+```bash
+npm install
+npm run build
+node ./bin/cli.js path/to/Your.sln
+```
+
+## Usage
+
+```text
+Usage:
+  sln2csproj <solution.sln> [options]
+
+Options:
+  --pick <N>        Select Nth Website project if multiple exist
+  --outDir <dir>    Output directory (default: tools/_intellisense)
+  --mode <copy|link>
+                    copy: copy referenced DLLs (default)
+                    link: reference original paths only
+  --check           List Website projects and exit
+  --verbose         Print detailed resolution info
+  -h, --help        Show help
+```
+
+## Examples
+
+### Default output
+
+```bash
+sln2csproj MyApp.sln
+```
+
+This writes output under:
+
+```text
+<solution-dir>\tools\_intellisense\<WebsiteName>\
+```
+
+### Custom output directory
+
+```bash
+sln2csproj MyApp.sln --outDir D:\temp\_intellisense
+```
+
+If `--outDir` is absolute, output is written there.
+If `--outDir` is relative, it is resolved from the solution directory.
+
+### List Website projects first
+
+```bash
+sln2csproj MyApp.sln --check
+```
+
+Useful when the solution contains more than one Website project.
+
+### Pick the second Website project
+
+```bash
+sln2csproj MyApp.sln --pick 2
+```
+
+### Link mode
+
+```bash
+sln2csproj MyApp.sln --mode link
+```
+
+### Verbose output
+
+```bash
+sln2csproj MyApp.sln --verbose
+```
+
+## Output Structure
+
+Example output:
+
+```text
+tools\_intellisense\HCT.SCTM.Web\
+  HCT.SCTM.Web.intellisense.csproj
+  fake_HCT.SCTM.Web.sln
+  refs\
+```
+
+Files:
+
+- `*.intellisense.csproj`: fake project for IntelliSense
+- `fake_*.sln`: rewritten solution that points the Website entry to the fake project
+- `refs\`: copied DLLs when `--mode copy` is used and DLL copy succeeds
+
+## Reference Resolution
+
+The generated fake `.csproj` includes:
+
+- standard .NET framework references
+- DLLs resolved from `.sln` Website `ProjectReferences`
+- DLLs already present in the website `Bin` folder, such as `Newtonsoft.Json.dll`
+
+This matters because many legacy WebSite projects depend on assemblies in `Bin` that are not listed as normal project references in the solution.
+
+## `copy` vs `link`
+
+### `--mode copy`
+
+Default mode.
+
+- copies resolved project DLLs into `refs\`
+- keeps the fake folder more self-contained
+- if DLL copy fails or a DLL is missing, it falls back to linking to the website `Bin` path
+
+### `--mode link`
+
+- does not copy project DLLs
+- references original resolved paths directly
+- useful when you do not want duplicated files
+
+Note:
+DLLs discovered directly from the website `Bin` folder are referenced from their original `Bin` location in both modes.
+
+## VS Code Workflow
+
+After generation:
+
+1. Open the generated folder under `tools/_intellisense/<WebsiteName>/`
+2. Let the C# extension load the fake `.sln` / `.csproj`
+3. Use IntelliSense against the original website source files
+4. Delete that generated website folder when you no longer need it
+
+In practice, deleting only the generated website subfolder is usually enough. You do not need to delete the whole `_intellisense` root.
+
+## Limitations
+
+- This is for IntelliSense, not for real builds
+- It does not convert WebSite projects into SDK-style projects
+- It does not guarantee every legacy dependency pattern will be inferred
+- Some environments may lock generated files while VS Code / OmniSharp is indexing them
+
+## Troubleshooting
+
+### `No Website Project found in the solution.`
+
+The `.sln` may not contain a legacy WebSite project entry, or the format may differ from what this tool supports.
+
+### `Newtonsoft` or another assembly is still unresolved
+
+Check whether the DLL exists in the website `Bin` folder.
+
+This tool now includes `Bin` DLLs in the generated fake project, but if the DLL is missing from `Bin`, IntelliSense still cannot resolve it.
+
+### Cannot delete generated `_intellisense` files
+
+Usually this is not a tool bug. The generated folder is often being used by:
+
+- VS Code
+- C# extension / Roslyn / OmniSharp
+- file indexers or security tools
+
+Close the generated fake solution/folder first, then delete only the target website subfolder under `_intellisense`.
+
+### Output inside the project is hard to delete in your environment
+
+Use a custom output path:
+
+```bash
+sln2csproj MyApp.sln --outDir D:\temp\_intellisense
+```
+
+## Test
+
+```bash
+npm test
+```
+
+The test suite covers:
+
+- solution parsing
+- fake `.csproj` generation
+- fake `.sln` rewriting
+- Chinese path handling
+- disk-based fixture parsing
+- CLI integration using a temporary workspace
+
+## Publish
+
+Create a local package tarball:
+
+```bash
+npm pack
+```
+
+Publish to npm:
+
+```bash
+npm publish
+```
+
+## GitHub Actions Publish
+
+This repository includes a GitHub Actions workflow at `.github/workflows/publish.yml`.
+
+It runs when:
+
+- you run the workflow manually from GitHub Actions
+- you push a tag such as `v0.2.0`
+
+Required setup:
+
+1. Create an npm granular access token with publish permission
+2. If your npm account requires it, make sure the token supports bypass 2FA
+3. Add the token to the GitHub repository secrets as `NPM_TOKEN`
+
+Suggested release flow:
+
+```bash
+git tag v0.2.0
+git push origin v0.2.0
+```
+
+The workflow will:
+
+- install dependencies
+- run tests
+- publish the npm package
+- build a Windows `exe`
+- attach the Windows `exe` and `.zip` to the GitHub Release when triggered by a version tag
+
+The Windows executable is built with Node.js Single Executable Applications (SEA), so Windows users can download it from GitHub Releases without installing Node first.

package/bin/cli.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const io_1 = require("./io");
+const parser_1 = require("./parser");
+const resolver_1 = require("./resolver");
+const generator_1 = require("./generator");
+const sln_1 = require("./sln");
+function collectWebsiteBinHintPaths(websiteAbs, websiteRelFromFake, hintByDll) {
+    const binDirAbs = path.join(websiteAbs, 'Bin');
+    if (!(0, io_1.exists)(binDirAbs))
+        return;
+    const existing = new Set(Array.from(hintByDll.keys(), key => key.toLowerCase()));
+    for (const name of fs.readdirSync(binDirAbs)) {
+        if (!/\.dll$/i.test(name))
+            continue;
+        const key = name.toLowerCase();
+        if (existing.has(key))
+            continue;
+        hintByDll.set(name, path.join(websiteRelFromFake, 'Bin', name).replace(/\//g, '\\'));
+        existing.add(key);
+    }
+}
+function usage() {
+    console.log([
+        'Usage:',
+        '  sln2csproj <solution.sln> [options]',
+        '',
+        'Options:',
+        '  --pick <N>        Select Nth Website project if multiple exist',
+        '  --outDir <dir>    Output directory (default: tools/_intellisense)',
+        '  --mode <copy|link>',
+        '                    copy: copy referenced DLLs (default)',
+        '                    link: reference original paths only',
+        '  --check           List Website projects and exit',
+        '  --verbose         Print detailed resolution info',
+        '  -h, --help        Show help',
+        '',
+        'Examples:',
+        '  sln2csproj MyApp.sln',
+        '  sln2csproj MyApp.sln --mode link --verbose',
+        '  sln2csproj MyApp.sln --check',
+    ].join('\n'));
+}
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    const opt = { slnPath: '' };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--pick') {
+            opt.pick = parseInt(args[++i], 10);
+            continue;
+        }
+        if (a === '--outDir') {
+            opt.outDir = args[++i];
+            continue;
+        }
+        if (a === '--mode') {
+            opt.mode = args[++i] || 'copy';
+            continue;
+        }
+        if (a === '--verbose') {
+            opt.verbose = true;
+            continue;
+        }
+        if (a === '--check') {
+            opt.check = true;
+            continue;
+        }
+        if (a === '--help' || a === '-h') {
+            opt.help = true;
+            continue;
+        }
+        if (!opt.slnPath)
+            opt.slnPath = a;
+    }
+    return opt;
+}
+function main() {
+    const opt = parseArgs(process.argv);
+    if (opt.help) {
+        usage();
+        process.exit(0);
+    }
+    if (!opt.slnPath) {
+        usage();
+        process.exit(1);
+    }
+    const slnAbs = path.resolve(opt.slnPath);
+    if (!(0, io_1.exists)(slnAbs)) {
+        console.error(`File not found: ${slnAbs}`);
+        process.exit(1);
+    }
+    const slnDir = path.dirname(slnAbs);
+    const outRootAbs = path.resolve(slnDir, opt.outDir || path.join('tools', '_intellisense'));
+    (0, io_1.mkdirp)(outRootAbs);
+    const slnContent = (0, io_1.readText)(slnAbs);
+    const blocks = (0, parser_1.splitSlnProjects)(slnContent);
+    const websites = (0, parser_1.parseWebsites)(blocks);
+    if (websites.length === 0) {
+        console.error('No Website Project found in the solution.');
+        process.exit(1);
+    }
+    if (opt.check) {
+        console.log('Website Projects:');
+        websites.forEach((w, i) => {
+            console.log(`${i + 1}. ${w.name}`);
+            console.log(`   PhysicalPath: ${w.physicalPath}`);
+            console.log(`   Framework: ${w.targetFramework}`);
+        });
+        if (websites.length > 1) {
+            console.log('\nMultiple Website projects found. Use --pick N to choose one.');
+            process.exit(2);
+        }
+        process.exit(0);
+    }
+    const pickIndex = Math.max(0, (opt.pick ?? 1) - 1);
+    const website = websites[Math.min(pickIndex, websites.length - 1)];
+    const csharpProjects = (0, parser_1.parseCSharpProjects)(blocks);
+    (0, resolver_1.resolveDlls)(slnDir, website, csharpProjects);
+    const safeName = website.name.replace(/[<>:"/\\|?*]+/g, '_');
+    const fakeDirAbs = path.join(outRootAbs, safeName);
+    (0, io_1.mkdirp)(fakeDirAbs);
+    const websiteAbs = path.join(slnDir, website.physicalPath);
+    const websiteRelFromFake = path.relative(fakeDirAbs, websiteAbs).replace(/\//g, '\\') || '.';
+    const mode = opt.mode || 'copy';
+    const refsDirAbs = path.join(fakeDirAbs, 'refs');
+    const hintByDll = (0, resolver_1.materializeRefs)(mode, fakeDirAbs, refsDirAbs, websiteAbs, websiteRelFromFake, website);
+    collectWebsiteBinHintPaths(websiteAbs, websiteRelFromFake, hintByDll);
+    const csprojContent = (0, generator_1.generateFakeCsproj)(website, websiteRelFromFake, hintByDll);
+    const csprojPath = path.join(fakeDirAbs, `${safeName}.intellisense.csproj`);
+    (0, io_1.writeText)(csprojPath, csprojContent);
+    const fakeSlnContent = (0, sln_1.buildFakeSln)(slnContent, slnDir, fakeDirAbs, website, csprojPath);
+    const fakeSlnPath = path.join(fakeDirAbs, `fake_${safeName}.sln`);
+    (0, io_1.writeText)(fakeSlnPath, fakeSlnContent);
+    console.log(`Website: ${website.name}`);
+    console.log(`   PhysicalPath: ${website.physicalPath}`);
+    console.log(`   Framework: ${website.targetFramework}`);
+    console.log(`Output: ${csprojPath}`);
+    console.log(`   Mode: ${mode}`);
+    console.log(`   Refs: ${website.projectReferences.length}`);
+    console.log(`Fake SLN: ${fakeSlnPath}`);
+    if (opt.verbose) {
+        console.log('\nDependencies:');
+        for (const ref of website.projectReferences) {
+            const hint = hintByDll.get(ref.dllName) || '(none)';
+            console.log(`- ${ref.dllName}`);
+            console.log(`  from: ${ref.resolvedFrom || ''}`);
+            console.log(`  hint: ${hint}`);
+        }
+    }
+    console.log('\nVS Code: open tools/_intellisense/<WebsiteName>/ and delete the folder when finished.');
+}
+main();

package/bin/generator.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFakeCsproj = generateFakeCsproj;
+const path = __importStar(require("path"));
+function esc(s) {
+    return s
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+/**
+ * websiteRelFromFake: 例如 "..\\..\\..\\HCT.WebSite"
+ * hintByDll: dllName -> HintPath (relative to fake project dir)
+ */
+function generateFakeCsproj(website, websiteRelFromFake, hintByDll) {
+    const prefix = websiteRelFromFake.replace(/\//g, '\\').replace(/\\+$/, '');
+    const compileInclude = esc(path.join(prefix, '**', '*.cs')).replace(/\//g, '\\');
+    const compileExclude = [
+        path.join(prefix, 'obj', '**'),
+        path.join(prefix, 'bin', '**'),
+        path.join(prefix, 'Bin', '**'),
+        path.join(prefix, 'App_Data', '**'),
+        path.join(prefix, 'Packages', '**'),
+        path.join(prefix, 'node_modules', '**'),
+        path.join(prefix, '**', 'Temporary ASP.NET Files', '**'),
+        path.join(prefix, 'Properties', 'AssemblyInfo.cs'),
+    ].map(s => s.replace(/\//g, '\\')).join(';');
+    const contentPatterns = ['aspx', 'ascx', 'master', 'ashx', 'asmx', 'config', 'asax'].map(ext => {
+        const inc = esc(path.join(prefix, '**', `*.${ext}`)).replace(/\//g, '\\');
+        return `    <Content Include="${inc}" />`;
+    }).join('\n');
+    const references = Array.from(hintByDll.entries()).map(([dllName, hintPath]) => {
+        const includeName = esc(dllName.replace(/\.dll$/i, ''));
+        const hint = esc(hintPath || path.join(prefix, 'Bin', dllName)).replace(/\//g, '\\');
+        return `    <Reference Include="${includeName}">
+      <HintPath>${hint}</HintPath>
+      <Private>False</Private>
+    </Reference>`;
+    }).join('\n');
+    return `<?xml version="1.0" encoding="utf-8"?>
+<!-- ⚠️ 此檔案由 sln2csproj 自動產生 -->
+<!-- ⚠️ 僅供 IntelliSense 使用，請勿拿來 build -->
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{${website.guid}}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <RootNamespace>${esc(website.name.replace(/\./g, '_'))}</RootNamespace>
+    <AssemblyName>${esc(website.name)}</AssemblyName>
+    <TargetFrameworkVersion>${esc(website.targetFramework)}</TargetFrameworkVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <!-- 基本 Framework refs -->
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Web" />
+    <Reference Include="System.Web.Extensions" />
+    <Reference Include="System.Web.Services" />
+    <Reference Include="System.Xml" />
+    <Reference Include="System.Configuration" />
+    <Reference Include="System.Xml.Linq" />
+
+    <!-- 從 sln 解析出的 refs -->
+${references}
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="${compileInclude}" Exclude="${esc(compileExclude)}" />
+  </ItemGroup>
+
+  <ItemGroup>
+${contentPatterns}
+  </ItemGroup>
+
+  <Import Project="$(MSBuildToolsPath)\\Microsoft.CSharp.targets" />
+
+  <Target Name="Build">
+    <Message Text="[INFO] fake csproj for IntelliSense only" Importance="high" />
+  </Target>
+</Project>`;
+}

package/bin/io.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readText = readText;
+exports.exists = exists;
+exports.mkdirp = mkdirp;
+exports.writeText = writeText;
+exports.copyFile = copyFile;
+const fs = __importStar(require("fs"));
+function readText(p) {
+    return fs.readFileSync(p, 'utf8');
+}
+function exists(p) {
+    try {
+        return fs.existsSync(p);
+    }
+    catch {
+        return false;
+    }
+}
+function mkdirp(p) {
+    fs.mkdirSync(p, { recursive: true });
+}
+function writeText(p, content) {
+    fs.writeFileSync(p, content, 'utf8');
+}
+function copyFile(src, dst) {
+    fs.copyFileSync(src, dst);
+}

package/bin/parser.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitSlnProjects = splitSlnProjects;
+exports.parseWebsites = parseWebsites;
+exports.parseCSharpProjects = parseCSharpProjects;
+const WEBSITE_TYPE_GUID = 'E24C65DC-7377-472B-9ABA-BC803B73C61A';
+const CSHARP_LEGACY_TYPE_GUID = 'FAE04EC0-301F-11D3-BF4B-00C04F79EFBC';
+const CSHARP_SDK_TYPE_GUID = '9A19103F-16F7-4668-BE54-9A1E7A4F7556';
+function splitSlnProjects(slnContent) {
+    const blocks = [];
+    const lineRe = /^.*(?:\r?\n|$)/gm;
+    const projectHeaderRe = /^Project\("?\{([0-9A-Fa-f\-]+)\}"?\)\s*=\s*"([^"]+)",\s*"([^"]+)",\s*"\{([0-9A-Fa-f\-]+)\}"\s*$/;
+    let activeStart = -1;
+    let activeMeta = null;
+    let match;
+    while ((match = lineRe.exec(slnContent)) !== null) {
+        const fullLine = match[0];
+        if (fullLine.length === 0)
+            break;
+        const line = fullLine.replace(/\r?\n$/, '');
+        if (!activeMeta) {
+            const header = line.trim().match(projectHeaderRe);
+            if (!header)
+                continue;
+            activeStart = match.index;
+            activeMeta = {
+                typeGuid: header[1],
+                name: header[2],
+                relPath: header[3],
+                guid: header[4],
+            };
+            continue;
+        }
+        if (/^\s*EndProject\s*$/.test(line)) {
+            blocks.push({
+                ...activeMeta,
+                rawBlock: slnContent.slice(activeStart, match.index + line.length),
+            });
+            activeStart = -1;
+            activeMeta = null;
+        }
+    }
+    return blocks;
+}
+function parseWebsiteProperties(block) {
+    const props = {};
+    const lines = block.split(/\r?\n/);
+    let inWebsiteProperties = false;
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!inWebsiteProperties) {
+            if (/^ProjectSection\(WebsiteProperties\)\s*=\s*preProject\s*$/i.test(line)) {
+                inWebsiteProperties = true;
+            }
+            continue;
+        }
+        if (/^EndProjectSection\s*$/i.test(line)) {
+            break;
+        }
+        const match = rawLine.match(/^\s*([A-Za-z0-9.\-_]+)\s*=\s*"([^"]*)"\s*$/);
+        if (!match)
+            continue;
+        props[match[1]] = match[2];
+    }
+    return props;
+}
+function normalizeFramework(raw) {
+    if (!raw || !raw.trim())
+        return 'v3.5';
+    const s = raw.trim();
+    if (s.startsWith('v'))
+        return s;
+    const m1 = s.match(/Version\s*=\s*(v?\d+(\.\d+)?)/i);
+    if (m1?.[1])
+        return m1[1].startsWith('v') ? m1[1] : `v${m1[1]}`;
+    if (/^\d+(\.\d+)?$/.test(s))
+        return `v${s}`;
+    const m3 = s.match(/^net(\d)(\d)$/i);
+    if (m3)
+        return `v${m3[1]}.${m3[2]}`;
+    return 'v3.5';
+}
+function parseWebsiteProjectReferences(value) {
+    if (!value)
+        return [];
+    return value
+        .split(';')
+        .map(s => s.trim())
+        .filter(Boolean)
+        .map(item => item.split('|'))
+        .filter(parts => parts.length === 2)
+        .map(parts => ({
+        guid: parts[0].replace(/[{}]/g, '').trim(),
+        dllName: parts[1].trim(),
+    }));
+}
+function parseWebsites(blocks) {
+    const websiteBlocks = blocks.filter(b => b.typeGuid.toUpperCase() === WEBSITE_TYPE_GUID);
+    return websiteBlocks.map(b => {
+        const props = parseWebsiteProperties(b.rawBlock);
+        const targetFramework = normalizeFramework(props['TargetFramework'] || props['TargetFrameworkVersion']);
+        const physicalPath = (props['Debug.AspNetCompiler.PhysicalPath'] ||
+            props['Release.AspNetCompiler.PhysicalPath'] ||
+            b.relPath)
+            .replace(/\\+$/, '')
+            .replace(/\/+$/, '');
+        return {
+            name: b.name,
+            guid: b.guid,
+            physicalPath,
+            targetFramework,
+            projectReferences: parseWebsiteProjectReferences(props['ProjectReferences']),
+        };
+    });
+}
+function parseCSharpProjects(blocks) {
+    return blocks
+        .filter(b => {
+        const tg = b.typeGuid.toUpperCase();
+        return tg === CSHARP_LEGACY_TYPE_GUID || tg === CSHARP_SDK_TYPE_GUID;
+    })
+        .map(b => ({
+        guid: b.guid,
+        name: b.name,
+        relPath: b.relPath,
+    }));
+}

package/bin/resolver.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDlls = resolveDlls;
+exports.materializeRefs = materializeRefs;
+const path = __importStar(require("path"));
+const io_1 = require("./io");
+function tryReadCsprojInfo(csprojAbsPath) {
+    if (!(0, io_1.exists)(csprojAbsPath))
+        return {};
+    const xml = (0, io_1.readText)(csprojAbsPath);
+    const am = xml.match(/<AssemblyName>\s*([^<]+)\s*<\/AssemblyName>/i);
+    const assemblyName = am?.[1]?.trim();
+    function pick(config) {
+        const rg = new RegExp(`<PropertyGroup[^>]*Condition="[^"]*${config}\\|AnyCPU[^"]*"[^>]*>[\\s\\S]*?<OutputPath>\\s*([^<]+)\\s*<\\/OutputPath>`, 'i');
+        return xml.match(rg)?.[1]?.trim();
+    }
+    return { assemblyName, debugOutputPath: pick('Debug'), releaseOutputPath: pick('Release') };
+}
+function limitedFindDllUnderProject(projDir, dllName) {
+    const candidates = [
+        path.join(projDir, 'bin', 'Debug', dllName),
+        path.join(projDir, 'bin', 'Release', dllName),
+        path.join(projDir, 'bin', dllName),
+    ];
+    for (const p of candidates)
+        if ((0, io_1.exists)(p))
+            return p;
+    return null;
+}
+function resolveDlls(slnDir, website, csharpProjects) {
+    const websiteAbs = path.join(slnDir, website.physicalPath);
+    for (const ref of website.projectReferences) {
+        const proj = csharpProjects.find(p => p.guid.toLowerCase() === ref.guid.toLowerCase());
+        if (!proj) {
+            const binAbs = path.join(websiteAbs, 'Bin', ref.dllName);
+            ref.resolvedAbs = (0, io_1.exists)(binAbs) ? binAbs : path.join(websiteAbs, 'Bin', ref.dllName);
+            ref.resolvedFrom = (0, io_1.exists)(binAbs) ? 'website:Bin' : 'guess:website Bin';
+            continue;
+        }
+        ref.projectPath = proj.relPath;
+        const csprojAbs = path.join(slnDir, proj.relPath);
+        const projDirAbs = path.dirname(csprojAbs);
+        const info = tryReadCsprojInfo(csprojAbs);
+        const assemblyGuess = info.assemblyName ? `${info.assemblyName}.dll` : ref.dllName;
+        const byOutputPath = (outRaw) => {
+            if (!outRaw)
+                return null;
+            const outAbs = path.resolve(projDirAbs, outRaw);
+            const a = path.join(outAbs, ref.dllName);
+            const b = path.join(outAbs, assemblyGuess);
+            if ((0, io_1.exists)(a))
+                return a;
+            if ((0, io_1.exists)(b))
+                return b;
+            return a; // guess path (may not exist)
+        };
+        let dllAbs = byOutputPath(info.debugOutputPath);
+        let from = 'csproj:Debug OutputPath';
+        if (dllAbs && !(0, io_1.exists)(dllAbs)) {
+            const rel = byOutputPath(info.releaseOutputPath);
+            if (rel) {
+                dllAbs = rel;
+                from = 'csproj:Release OutputPath';
+            }
+        }
+        if (!dllAbs || !(0, io_1.exists)(dllAbs)) {
+            const found = limitedFindDllUnderProject(projDirAbs, ref.dllName);
+            if (found) {
+                dllAbs = found;
+                from = 'fallback:bin';
+            }
+            else {
+                dllAbs = path.join(projDirAbs, 'bin', 'Debug', ref.dllName);
+                from = 'guess:bin\\Debug';
+            }
+        }
+        ref.resolvedAbs = dllAbs;
+        ref.resolvedFrom = from;
+    }
+}
+/**
+ * mode=copy 時，把 resolvedAbs 存在的 dll 複製到 refsDir，
+ * 回傳每個 ref 的 HintPath（相對於 fake project dir）
+ */
+function materializeRefs(mode, fakeDirAbs, refsDirAbs, websiteAbs, websiteRelFromFake, website) {
+    const hintByDll = new Map();
+    if (mode === 'copy') {
+        (0, io_1.mkdirp)(refsDirAbs);
+        for (const ref of website.projectReferences) {
+            const dllName = ref.dllName;
+            const src = ref.resolvedAbs;
+            const dst = path.join(refsDirAbs, dllName);
+            if (src && (0, io_1.exists)(src)) {
+                try {
+                    (0, io_1.copyFile)(src, dst);
+                    hintByDll.set(dllName, path.relative(fakeDirAbs, dst).replace(/\//g, '\\')); // usually "refs\\X.dll"
+                }
+                catch {
+                    // fallback to link if copy fails
+                    const linked = path.join(websiteAbs, 'Bin', dllName);
+                    hintByDll.set(dllName, path.join(websiteRelFromFake, 'Bin', dllName).replace(/\//g, '\\'));
+                    ref.resolvedFrom = (ref.resolvedFrom || '') + ' + copyFail->link';
+                }
+            }
+            else {
+                // fallback: link to website Bin
+                hintByDll.set(dllName, path.join(websiteRelFromFake, 'Bin', dllName).replace(/\//g, '\\'));
+                ref.resolvedFrom = (ref.resolvedFrom || '') + ' + missing->link';
+            }
+        }
+        return hintByDll;
+    }
+    // mode === 'link'
+    for (const ref of website.projectReferences) {
+        const dllName = ref.dllName;
+        // Prefer resolvedAbs if exists, else website Bin
+        if (ref.resolvedAbs && (0, io_1.exists)(ref.resolvedAbs)) {
+            hintByDll.set(dllName, path.relative(fakeDirAbs, ref.resolvedAbs).replace(/\//g, '\\'));
+        }
+        else {
+            hintByDll.set(dllName, path.join(websiteRelFromFake, 'Bin', dllName).replace(/\//g, '\\'));
+        }
+    }
+    return hintByDll;
+}

package/bin/sln.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFakeSln = buildFakeSln;
+const path = __importStar(require("path"));
+const parser_1 = require("./parser");
+const CSHARP_LEGACY_TYPE_GUID = 'FAE04EC0-301F-11D3-BF4B-00C04F79EFBC';
+function detectEol(text) {
+    return text.includes('\r\n') ? '\r\n' : '\n';
+}
+function isUrlLike(p) {
+    return /:\/\//.test(p);
+}
+function adjustRelPath(relPath, slnDir, fakeSlnDir) {
+    if (!relPath)
+        return relPath;
+    if (isUrlLike(relPath))
+        return relPath;
+    if (path.isAbsolute(relPath))
+        return relPath;
+    const abs = path.resolve(slnDir, relPath);
+    const rel = path.relative(fakeSlnDir, abs) || '.';
+    return rel.replace(/\//g, '\\');
+}
+function replaceProjectPathInBlock(rawBlock, newRelPath) {
+    const re = /(Project\("?\{[0-9A-Fa-f\-]+\}"?\)\s*=\s*"[^"]+",\s*")([^"]+)(".*)/;
+    return rawBlock.replace(re, `$1${newRelPath}$3`);
+}
+function makeProjectBlock(typeGuid, name, relPath, guid, eol) {
+    return `Project("{${typeGuid}}") = "${name}", "${relPath}", "{${guid}}"${eol}EndProject`;
+}
+function buildFakeSln(slnContent, slnDir, fakeSlnDir, website, fakeCsprojAbs) {
+    const blocks = (0, parser_1.splitSlnProjects)(slnContent);
+    const eol = detectEol(slnContent);
+    let output = slnContent;
+    for (const b of blocks) {
+        if (b.guid.toLowerCase() === website.guid.toLowerCase()) {
+            const rel = path.relative(fakeSlnDir, fakeCsprojAbs).replace(/\//g, '\\') || '.';
+            const newBlock = makeProjectBlock(CSHARP_LEGACY_TYPE_GUID, b.name, rel, b.guid, eol);
+            output = output.replace(b.rawBlock, newBlock);
+            continue;
+        }
+        const adjusted = adjustRelPath(b.relPath, slnDir, fakeSlnDir);
+        const newBlock = replaceProjectPathInBlock(b.rawBlock, adjusted);
+        output = output.replace(b.rawBlock, newBlock);
+    }
+    return output;
+}

package/bin/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "sln2csproj",
+  "version": "0.2.0",
+  "description": "Generate a fake csproj for legacy ASP.NET WebSite projects in a .sln.",
+  "type": "commonjs",
+  "bin": {
+    "sln2csproj": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "ts-node src/cli.ts",
+    "gen": "node bin/cli.js",
+    "pretest": "npm run build",
+    "test": "node --test",
+    "prepare": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.17.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.4"
+  }
+}