@shrkcrft/workspace 0.1.0-alpha.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SharkCraft contributors
+
+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,15 @@
+# @shrkcrft/workspace
+
+SharkCraft workspace inspector: project root, package.json, package manager, frameworks, tsconfig.
+
+Part of [SharkCraft](https://github.com/shrkcrft/sharkcraft) — a deterministic, local-first toolkit that gives AI coding agents durable project context. See the main repo for documentation, examples, and the `shrk` CLI.
+
+## Install
+
+```bash
+bun add @shrkcrft/workspace
+```
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/folder-scanner.d.ts

@@ -0,0 +1,13 @@
+export interface IFolderInfo {
+    path: string;
+    exists: boolean;
+    files: number;
+    dirs: number;
+}
+export declare function shallowScanFolder(dir: string): IFolderInfo;
+export declare function listTopLevelDirs(projectRoot: string, limit?: number): string[];
+export declare function findFiles(startDir: string, pattern: RegExp, options?: {
+    maxDepth?: number;
+    ignore?: Set<string>;
+}): string[];
+//# sourceMappingURL=folder-scanner.d.ts.map

package/dist/folder-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"folder-scanner.d.ts","sourceRoot":"","sources":["../src/folder-scanner.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAeD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAc1D;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,MAAM,EAAE,CAU1E;AAED,wBAAgB,SAAS,CACvB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAO,GACxD,MAAM,EAAE,CAoBV"}

package/dist/folder-scanner.js

@@ -0,0 +1,73 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+const DEFAULT_IGNORE = new Set([
+    'node_modules',
+    '.git',
+    '.idea',
+    '.vscode',
+    'dist',
+    'build',
+    '.cache',
+    '.nx',
+    '.turbo',
+    'coverage',
+]);
+export function shallowScanFolder(dir) {
+    if (!existsSync(dir))
+        return { path: dir, exists: false, files: 0, dirs: 0 };
+    try {
+        let files = 0;
+        let dirs = 0;
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const e of entries) {
+            if (e.isDirectory())
+                dirs += 1;
+            else if (e.isFile())
+                files += 1;
+        }
+        return { path: dir, exists: true, files, dirs };
+    }
+    catch {
+        return { path: dir, exists: true, files: 0, dirs: 0 };
+    }
+}
+export function listTopLevelDirs(projectRoot, limit = 40) {
+    if (!existsSync(projectRoot))
+        return [];
+    try {
+        return readdirSync(projectRoot, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && !DEFAULT_IGNORE.has(e.name))
+            .map((e) => e.name)
+            .slice(0, limit);
+    }
+    catch {
+        return [];
+    }
+}
+export function findFiles(startDir, pattern, options = {}) {
+    const { maxDepth = 4, ignore = DEFAULT_IGNORE } = options;
+    const out = [];
+    function walk(dir, depth) {
+        if (depth > maxDepth)
+            return;
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const e of entries) {
+                const name = String(e.name);
+                if (ignore.has(name))
+                    continue;
+                const full = nodePath.join(dir, name);
+                if (e.isDirectory())
+                    walk(full, depth + 1);
+                else if (e.isFile() && pattern.test(name))
+                    out.push(full);
+            }
+        }
+        catch {
+            return;
+        }
+    }
+    if (existsSync(startDir) && statSync(startDir).isDirectory())
+        walk(startDir, 0);
+    return out;
+}

package/dist/framework-detector.d.ts

@@ -0,0 +1,9 @@
+import type { IPackageJson } from './package-json-reader.js';
+export interface IFrameworkInfo {
+    id: string;
+    name: string;
+    version?: string;
+    evidence: string[];
+}
+export declare function detectFrameworks(projectRoot: string, pkg: IPackageJson | null): IFrameworkInfo[];
+//# sourceMappingURL=framework-detector.d.ts.map

package/dist/framework-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-detector.d.ts","sourceRoot":"","sources":["../src/framework-detector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AA0BD,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,IAAI,GAAG,cAAc,EAAE,CA6BhG"}

package/dist/framework-detector.js

@@ -0,0 +1,45 @@
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+const FRAMEWORKS = [
+    { id: 'angular', name: 'Angular', packages: ['@angular/core', '@angular/cli'], fileMarkers: ['angular.json'] },
+    { id: 'react', name: 'React', packages: ['react'] },
+    { id: 'vue', name: 'Vue', packages: ['vue'] },
+    { id: 'svelte', name: 'Svelte', packages: ['svelte'] },
+    { id: 'nextjs', name: 'Next.js', packages: ['next'] },
+    { id: 'nuxt', name: 'Nuxt', packages: ['nuxt'] },
+    { id: 'nestjs', name: 'NestJS', packages: ['@nestjs/core'] },
+    { id: 'express', name: 'Express', packages: ['express'] },
+    { id: 'fastify', name: 'Fastify', packages: ['fastify'] },
+    { id: 'nx', name: 'Nx', packages: ['nx', '@nx/workspace'], fileMarkers: ['nx.json'] },
+    { id: 'aws-lambda', name: 'AWS Lambda', packages: ['aws-lambda', '@types/aws-lambda'] },
+    { id: 'electron', name: 'Electron', packages: ['electron'] },
+    { id: 'typescript', name: 'TypeScript', packages: ['typescript'], fileMarkers: ['tsconfig.json', 'tsconfig.base.json'] },
+    { id: 'bun', name: 'Bun', packages: ['bun-types', '@types/bun'], fileMarkers: ['bun.lockb', 'bun.lock'] },
+];
+export function detectFrameworks(projectRoot, pkg) {
+    const out = [];
+    const allDeps = {
+        ...(pkg?.dependencies ?? {}),
+        ...(pkg?.devDependencies ?? {}),
+        ...(pkg?.peerDependencies ?? {}),
+    };
+    for (const def of FRAMEWORKS) {
+        const evidence = [];
+        let version;
+        for (const pkgName of def.packages) {
+            if (pkgName in allDeps) {
+                evidence.push(`depends on ${pkgName}`);
+                version = version ?? allDeps[pkgName];
+            }
+        }
+        for (const marker of def.fileMarkers ?? []) {
+            if (existsSync(nodePath.join(projectRoot, marker))) {
+                evidence.push(`${marker} exists`);
+            }
+        }
+        if (evidence.length > 0) {
+            out.push({ id: def.id, name: def.name, version, evidence });
+        }
+    }
+    return out;
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './project-root-detector.js';
+export * from './package-json-reader.js';
+export * from './package-manager-detector.js';
+export * from './framework-detector.js';
+export * from './tsconfig-reader.js';
+export * from './folder-scanner.js';
+export * from './profile-detector.js';
+export * from './workspace-summary.js';
+export * from './workspace-inspector.js';
+export * from './project-shape.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./project-root-detector.js";
+export * from "./package-json-reader.js";
+export * from "./package-manager-detector.js";
+export * from "./framework-detector.js";
+export * from "./tsconfig-reader.js";
+export * from "./folder-scanner.js";
+export * from "./profile-detector.js";
+export * from "./workspace-summary.js";
+export * from "./workspace-inspector.js";
+export * from "./project-shape.js";

package/dist/package-json-reader.d.ts

@@ -0,0 +1,21 @@
+import { type AppError, type Result } from '@shrkcrft/core';
+export interface IPackageJson {
+    name?: string;
+    version?: string;
+    description?: string;
+    private?: boolean;
+    type?: 'module' | 'commonjs';
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    workspaces?: string[] | {
+        packages?: string[];
+    };
+    packageManager?: string;
+    engines?: Record<string, string>;
+    bin?: string | Record<string, string>;
+    [key: string]: unknown;
+}
+export declare function readPackageJson(projectRoot: string): Result<IPackageJson | null, AppError>;
+//# sourceMappingURL=package-json-reader.d.ts.map

package/dist/package-json-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-json-reader.d.ts","sourceRoot":"","sources":["../src/package-json-reader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAsC,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAEhG,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG;QAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAChD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC,YAAY,GAAG,IAAI,EAAE,QAAQ,CAAC,CAc1F"}

package/dist/package-json-reader.js

@@ -0,0 +1,18 @@
+import { existsSync, readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { AppErrorImpl, ERROR_CODES, err, ok } from '@shrkcrft/core';
+export function readPackageJson(projectRoot) {
+    const pkgPath = nodePath.join(projectRoot, 'package.json');
+    if (!existsSync(pkgPath))
+        return ok(null);
+    try {
+        const raw = readFileSync(pkgPath, 'utf8');
+        return ok(JSON.parse(raw));
+    }
+    catch (e) {
+        return err(new AppErrorImpl(ERROR_CODES.FILE_READ_ERROR, `Failed to parse package.json: ${pkgPath}`, {
+            details: { pkgPath },
+            cause: e,
+        }));
+    }
+}

package/dist/package-manager-detector.d.ts

@@ -0,0 +1,15 @@
+import type { IPackageJson } from './package-json-reader.js';
+export declare enum PackageManager {
+    Bun = "bun",
+    Pnpm = "pnpm",
+    Yarn = "yarn",
+    Npm = "npm",
+    Unknown = "unknown"
+}
+export interface IPackageManagerInfo {
+    manager: PackageManager;
+    version?: string;
+    evidence: string[];
+}
+export declare function detectPackageManager(projectRoot: string, pkg: IPackageJson | null): IPackageManagerInfo;
+//# sourceMappingURL=package-manager-detector.d.ts.map

package/dist/package-manager-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-manager-detector.d.ts","sourceRoot":"","sources":["../src/package-manager-detector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,oBAAY,cAAc;IACxB,GAAG,QAAQ;IACX,IAAI,SAAS;IACb,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,OAAO,YAAY;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,cAAc,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,IAAI,GAAG,mBAAmB,CAmCvG"}

package/dist/package-manager-detector.js

@@ -0,0 +1,47 @@
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+export var PackageManager;
+(function (PackageManager) {
+    PackageManager["Bun"] = "bun";
+    PackageManager["Pnpm"] = "pnpm";
+    PackageManager["Yarn"] = "yarn";
+    PackageManager["Npm"] = "npm";
+    PackageManager["Unknown"] = "unknown";
+})(PackageManager || (PackageManager = {}));
+export function detectPackageManager(projectRoot, pkg) {
+    const evidence = [];
+    if (pkg?.packageManager) {
+        const [name, version] = pkg.packageManager.split('@');
+        evidence.push(`packageManager field: ${pkg.packageManager}`);
+        const manager = (name ?? '').toLowerCase();
+        if (manager === 'bun')
+            return { manager: PackageManager.Bun, version, evidence };
+        if (manager === 'pnpm')
+            return { manager: PackageManager.Pnpm, version, evidence };
+        if (manager === 'yarn')
+            return { manager: PackageManager.Yarn, version, evidence };
+        if (manager === 'npm')
+            return { manager: PackageManager.Npm, version, evidence };
+    }
+    if (existsSync(nodePath.join(projectRoot, 'bun.lockb'))) {
+        evidence.push('bun.lockb present');
+        return { manager: PackageManager.Bun, evidence };
+    }
+    if (existsSync(nodePath.join(projectRoot, 'bun.lock'))) {
+        evidence.push('bun.lock present');
+        return { manager: PackageManager.Bun, evidence };
+    }
+    if (existsSync(nodePath.join(projectRoot, 'pnpm-lock.yaml'))) {
+        evidence.push('pnpm-lock.yaml present');
+        return { manager: PackageManager.Pnpm, evidence };
+    }
+    if (existsSync(nodePath.join(projectRoot, 'yarn.lock'))) {
+        evidence.push('yarn.lock present');
+        return { manager: PackageManager.Yarn, evidence };
+    }
+    if (existsSync(nodePath.join(projectRoot, 'package-lock.json'))) {
+        evidence.push('package-lock.json present');
+        return { manager: PackageManager.Npm, evidence };
+    }
+    return { manager: PackageManager.Unknown, evidence };
+}

package/dist/profile-detector.d.ts

@@ -0,0 +1,47 @@
+import type { IPackageJson } from './package-json-reader.js';
+import type { IFrameworkInfo } from './framework-detector.js';
+export declare enum WorkspaceProfile {
+    HasBun = "has-bun",
+    HasTypeScript = "has-typescript",
+    HasNx = "has-nx",
+    HasTurborepo = "has-turborepo",
+    HasReact = "has-react",
+    HasNext = "has-next",
+    HasAngular = "has-angular",
+    HasVue = "has-vue",
+    HasNestJS = "has-nestjs",
+    HasMcpSdk = "has-mcp-sdk",
+    HasTests = "has-tests",
+    HasEslint = "has-eslint",
+    HasBiome = "has-biome",
+    HasVitest = "has-vitest",
+    HasJest = "has-jest",
+    HasBunTest = "has-bun-test",
+    HasGithubActions = "has-github-actions",
+    HasPackageWorkspaces = "has-package-workspaces",
+    IsLibrary = "is-library",
+    IsService = "is-service",
+    IsMonorepo = "is-monorepo",
+    IsFrontend = "is-frontend",
+    IsBackend = "is-backend"
+}
+export interface IProfileEvidence {
+    profile: WorkspaceProfile;
+    reason: string;
+}
+export interface IProfileDetectionResult {
+    profiles: WorkspaceProfile[];
+    evidence: IProfileEvidence[];
+}
+export interface IDetectProfilesInput {
+    packageJson: IPackageJson | null;
+    frameworks: readonly IFrameworkInfo[];
+    topLevelDirs: readonly string[];
+    hasTsConfig: boolean;
+}
+/**
+ * Compute structured profile tags from a workspace inspection. Pure function:
+ * no I/O. Each detected profile has an `evidence` entry explaining why.
+ */
+export declare function detectProfiles(input: IDetectProfilesInput): IProfileDetectionResult;
+//# sourceMappingURL=profile-detector.d.ts.map

package/dist/profile-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile-detector.d.ts","sourceRoot":"","sources":["../src/profile-detector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAE9D,oBAAY,gBAAgB;IAC1B,MAAM,YAAY;IAClB,aAAa,mBAAmB;IAChC,KAAK,WAAW;IAChB,YAAY,kBAAkB;IAC9B,QAAQ,cAAc;IACtB,OAAO,aAAa;IACpB,UAAU,gBAAgB;IAC1B,MAAM,YAAY;IAClB,SAAS,eAAe;IACxB,SAAS,gBAAgB;IACzB,QAAQ,cAAc;IACtB,SAAS,eAAe;IACxB,QAAQ,cAAc;IACtB,SAAS,eAAe;IACxB,OAAO,aAAa;IACpB,UAAU,iBAAiB;IAC3B,gBAAgB,uBAAuB;IACvC,oBAAoB,2BAA2B;IAC/C,SAAS,eAAe;IACxB,SAAS,eAAe;IACxB,UAAU,gBAAgB;IAC1B,UAAU,gBAAgB;IAC1B,SAAS,eAAe;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,gBAAgB,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,YAAY,GAAG,IAAI,CAAC;IACjC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAC;IACtC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,WAAW,EAAE,OAAO,CAAC;CACtB;AA6BD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,oBAAoB,GAAG,uBAAuB,CAuInF"}

package/dist/profile-detector.js

@@ -0,0 +1,162 @@
+export var WorkspaceProfile;
+(function (WorkspaceProfile) {
+    WorkspaceProfile["HasBun"] = "has-bun";
+    WorkspaceProfile["HasTypeScript"] = "has-typescript";
+    WorkspaceProfile["HasNx"] = "has-nx";
+    WorkspaceProfile["HasTurborepo"] = "has-turborepo";
+    WorkspaceProfile["HasReact"] = "has-react";
+    WorkspaceProfile["HasNext"] = "has-next";
+    WorkspaceProfile["HasAngular"] = "has-angular";
+    WorkspaceProfile["HasVue"] = "has-vue";
+    WorkspaceProfile["HasNestJS"] = "has-nestjs";
+    WorkspaceProfile["HasMcpSdk"] = "has-mcp-sdk";
+    WorkspaceProfile["HasTests"] = "has-tests";
+    WorkspaceProfile["HasEslint"] = "has-eslint";
+    WorkspaceProfile["HasBiome"] = "has-biome";
+    WorkspaceProfile["HasVitest"] = "has-vitest";
+    WorkspaceProfile["HasJest"] = "has-jest";
+    WorkspaceProfile["HasBunTest"] = "has-bun-test";
+    WorkspaceProfile["HasGithubActions"] = "has-github-actions";
+    WorkspaceProfile["HasPackageWorkspaces"] = "has-package-workspaces";
+    WorkspaceProfile["IsLibrary"] = "is-library";
+    WorkspaceProfile["IsService"] = "is-service";
+    WorkspaceProfile["IsMonorepo"] = "is-monorepo";
+    WorkspaceProfile["IsFrontend"] = "is-frontend";
+    WorkspaceProfile["IsBackend"] = "is-backend";
+})(WorkspaceProfile || (WorkspaceProfile = {}));
+function hasDep(pkg, name) {
+    if (!pkg)
+        return false;
+    return (Boolean(pkg.dependencies?.[name]) ||
+        Boolean(pkg.devDependencies?.[name]) ||
+        Boolean(pkg.peerDependencies?.[name]));
+}
+function hasAnyDep(pkg, names) {
+    return names.some((n) => hasDep(pkg, n));
+}
+function hasFramework(frameworks, id) {
+    return frameworks.some((f) => f.id === id);
+}
+function hasScriptIncluding(pkg, ...needles) {
+    if (!pkg)
+        return false;
+    for (const v of Object.values(pkg.scripts ?? {})) {
+        for (const n of needles) {
+            if (typeof v === 'string' && v.includes(n))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Compute structured profile tags from a workspace inspection. Pure function:
+ * no I/O. Each detected profile has an `evidence` entry explaining why.
+ */
+export function detectProfiles(input) {
+    const { packageJson: pkg, frameworks, topLevelDirs, hasTsConfig } = input;
+    const evidence = [];
+    const add = (profile, reason) => {
+        if (!evidence.some((e) => e.profile === profile)) {
+            evidence.push({ profile, reason });
+        }
+    };
+    // ── Language / runtime ────────────────────────────────────────────────
+    if (hasFramework(frameworks, 'bun') || hasDep(pkg, 'bun') || hasDep(pkg, '@types/bun')) {
+        add(WorkspaceProfile.HasBun, 'bun runtime detected via deps or framework signal');
+    }
+    if (hasTsConfig || hasDep(pkg, 'typescript') || hasFramework(frameworks, 'typescript')) {
+        add(WorkspaceProfile.HasTypeScript, 'tsconfig.json or typescript dependency present');
+    }
+    // ── Build / workspace tooling ─────────────────────────────────────────
+    if (hasFramework(frameworks, 'nx') || hasDep(pkg, 'nx') || hasDep(pkg, '@nx/workspace')) {
+        add(WorkspaceProfile.HasNx, 'nx workspace detected');
+    }
+    if (hasDep(pkg, 'turbo') ||
+        topLevelDirs.includes('turbo.json') ||
+        topLevelDirs.includes('.turbo')) {
+        add(WorkspaceProfile.HasTurborepo, 'turbo dependency or turbo.json present');
+    }
+    if (Array.isArray(pkg?.workspaces)) {
+        add(WorkspaceProfile.HasPackageWorkspaces, 'package.json workspaces array');
+    }
+    if (hasFramework(frameworks, 'nx') ||
+        Array.isArray(pkg?.workspaces) ||
+        topLevelDirs.includes('packages') ||
+        topLevelDirs.includes('libs') ||
+        topLevelDirs.includes('apps')) {
+        add(WorkspaceProfile.IsMonorepo, 'workspaces / Nx / packages/libs dirs present');
+    }
+    // ── UI frameworks ─────────────────────────────────────────────────────
+    if (hasFramework(frameworks, 'react') ||
+        hasAnyDep(pkg, ['react', 'react-dom', 'next', '@remix-run/react'])) {
+        add(WorkspaceProfile.HasReact, 'react family dependency or framework signal');
+    }
+    if (hasFramework(frameworks, 'next') || hasDep(pkg, 'next')) {
+        add(WorkspaceProfile.HasNext, 'next dependency or framework signal');
+    }
+    if (hasFramework(frameworks, 'angular') ||
+        hasAnyDep(pkg, ['@angular/core', '@angular/cli'])) {
+        add(WorkspaceProfile.HasAngular, '@angular/* dependency detected');
+    }
+    if (hasFramework(frameworks, 'vue') || hasAnyDep(pkg, ['vue', 'nuxt'])) {
+        add(WorkspaceProfile.HasVue, 'vue / nuxt dependency');
+    }
+    // ── Backend ───────────────────────────────────────────────────────────
+    if (hasFramework(frameworks, 'nestjs') ||
+        hasAnyDep(pkg, ['@nestjs/core', '@nestjs/common'])) {
+        add(WorkspaceProfile.HasNestJS, '@nestjs/* dependency');
+    }
+    if (hasDep(pkg, '@modelcontextprotocol/sdk')) {
+        add(WorkspaceProfile.HasMcpSdk, '@modelcontextprotocol/sdk dependency');
+    }
+    // ── Testing ───────────────────────────────────────────────────────────
+    if (hasDep(pkg, 'vitest'))
+        add(WorkspaceProfile.HasVitest, 'vitest dependency');
+    if (hasAnyDep(pkg, ['jest', '@jest/globals']))
+        add(WorkspaceProfile.HasJest, 'jest dependency');
+    if (hasScriptIncluding(pkg, 'bun test', 'bun:test') ||
+        (hasDep(pkg, '@types/bun') && hasScriptIncluding(pkg, 'test'))) {
+        add(WorkspaceProfile.HasBunTest, 'bun test script detected');
+    }
+    if (evidence.some((e) => e.profile === WorkspaceProfile.HasVitest) ||
+        evidence.some((e) => e.profile === WorkspaceProfile.HasJest) ||
+        evidence.some((e) => e.profile === WorkspaceProfile.HasBunTest) ||
+        hasScriptIncluding(pkg, 'test') ||
+        topLevelDirs.some((d) => d === 'tests' || d === '__tests__')) {
+        add(WorkspaceProfile.HasTests, 'test runner or test directory present');
+    }
+    // ── Lint ──────────────────────────────────────────────────────────────
+    if (hasAnyDep(pkg, ['eslint', '@eslint/js'])) {
+        add(WorkspaceProfile.HasEslint, 'eslint dependency');
+    }
+    if (hasAnyDep(pkg, ['@biomejs/biome'])) {
+        add(WorkspaceProfile.HasBiome, '@biomejs/biome dependency');
+    }
+    // ── CI ────────────────────────────────────────────────────────────────
+    if (topLevelDirs.includes('.github')) {
+        add(WorkspaceProfile.HasGithubActions, '.github directory present (likely workflows)');
+    }
+    // ── Library vs service vs frontend/backend ────────────────────────────
+    const looksLibrary = !!pkg?.main || !!pkg?.exports || !!pkg?.types;
+    if (looksLibrary && !topLevelDirs.includes('apps')) {
+        add(WorkspaceProfile.IsLibrary, 'package.json declares main/exports/types');
+    }
+    if (hasScriptIncluding(pkg, 'start', 'serve', 'dev:server') &&
+        !evidence.some((e) => e.profile === WorkspaceProfile.IsLibrary)) {
+        add(WorkspaceProfile.IsService, 'start/serve script detected');
+    }
+    const frontendSignal = evidence.some((e) => [WorkspaceProfile.HasReact, WorkspaceProfile.HasAngular, WorkspaceProfile.HasVue].includes(e.profile)) ||
+        hasAnyDep(pkg, ['vite', '@angular/build', 'next', 'remix']);
+    if (frontendSignal) {
+        add(WorkspaceProfile.IsFrontend, 'UI framework or frontend bundler dependency');
+    }
+    const backendSignal = evidence.some((e) => e.profile === WorkspaceProfile.HasNestJS) ||
+        hasAnyDep(pkg, ['express', 'fastify', 'koa', 'hono', '@nestjs/core']);
+    if (backendSignal) {
+        add(WorkspaceProfile.IsBackend, 'HTTP server framework dependency');
+    }
+    return {
+        profiles: evidence.map((e) => e.profile),
+        evidence,
+    };
+}

package/dist/project-root-detector.d.ts

@@ -0,0 +1,6 @@
+export interface IProjectRoot {
+    root: string;
+    markers: string[];
+}
+export declare function detectProjectRoot(startDir?: string): IProjectRoot;
+//# sourceMappingURL=project-root-detector.d.ts.map

package/dist/project-root-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-root-detector.d.ts","sourceRoot":"","sources":["../src/project-root-detector.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAWD,wBAAgB,iBAAiB,CAAC,QAAQ,GAAE,MAAsB,GAAG,YAAY,CAShF"}

package/dist/project-root-detector.js

@@ -0,0 +1,22 @@
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+const ROOT_MARKERS = [
+    'package.json',
+    'bun.lockb',
+    'pnpm-workspace.yaml',
+    'nx.json',
+    'tsconfig.base.json',
+    '.git',
+];
+export function detectProjectRoot(startDir = process.cwd()) {
+    let current = nodePath.resolve(startDir);
+    while (true) {
+        const found = ROOT_MARKERS.filter((m) => existsSync(nodePath.join(current, m)));
+        if (found.length > 0)
+            return { root: current, markers: found };
+        const parent = nodePath.dirname(current);
+        if (parent === current)
+            return { root: nodePath.resolve(startDir), markers: [] };
+        current = parent;
+    }
+}

package/dist/project-shape.d.ts

@@ -0,0 +1,57 @@
+import type { IPackageJson } from './package-json-reader.js';
+/**
+ * Coarse project-shape classification. Drives the default
+ * surface composition: a single-app repo hides monorepo-only
+ * commands by default; a library repo hides app-only commands.
+ */
+export declare enum ProjectShape {
+    SingleApp = "single-app",
+    AppWithLibs = "app-with-libs",
+    Monorepo = "monorepo",
+    Library = "library",
+    Unknown = "unknown"
+}
+export interface IProjectShapeDetection {
+    shape: ProjectShape;
+    evidence: readonly string[];
+    /** Hint signals the resolver collected during detection. */
+    signals: {
+        hasAngularJson: boolean;
+        hasNxJson: boolean;
+        nxProjectCount: number | null;
+        workspaceCount: number | null;
+        hasAppsDir: boolean;
+        hasLibsDir: boolean;
+        hasDevServeScript: boolean;
+        hasOnlyBuildTestScripts: boolean;
+    };
+}
+export interface DetectProjectShapeOptions {
+    projectRoot: string;
+    /** Pre-loaded package.json, if available. */
+    packageJson?: IPackageJson | null;
+}
+/**
+ * Deterministic project-shape detector. No AI, no heuristics
+ * beyond file/dependency presence. Result is cacheable.
+ *
+ * Rules (first match wins; subsequent signals contribute evidence
+ * but do not change the verdict):
+ *
+ *   1. `nx.json` present AND ≥6 Nx projects discovered → Monorepo.
+ *   2. `package.json workspaces` field with ≥3 entries → Monorepo.
+ *   3. `angular.json` workspace with exactly one project → SingleApp.
+ *   4. `apps/` AND `libs/` dirs present (Nx-style) → AppWithLibs.
+ *   5. `package.json` with build/test scripts but NO dev/serve/start
+ *      script AND no app dir → Library.
+ *   6. Otherwise → Unknown.
+ */
+export declare function detectProjectShape(options: DetectProjectShapeOptions): IProjectShapeDetection;
+export interface IProjectShapeCacheEntry {
+    schema: 'sharkcraft.shape.v1';
+    detection: IProjectShapeDetection;
+    cachedAt: string;
+}
+export declare function cacheProjectShape(projectRoot: string, detection: IProjectShapeDetection): string;
+export declare function readCachedProjectShape(projectRoot: string): IProjectShapeCacheEntry | null;
+//# sourceMappingURL=project-shape.d.ts.map

package/dist/project-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-shape.d.ts","sourceRoot":"","sources":["../src/project-shape.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;GAIG;AACH,oBAAY,YAAY;IACtB,SAAS,eAAe;IACxB,WAAW,kBAAkB;IAC7B,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,4DAA4D;IAC5D,OAAO,EAAE;QACP,cAAc,EAAE,OAAO,CAAC;QACxB,SAAS,EAAE,OAAO,CAAC;QACnB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;QAC9B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;QAC9B,UAAU,EAAE,OAAO,CAAC;QACpB,UAAU,EAAE,OAAO,CAAC;QACpB,iBAAiB,EAAE,OAAO,CAAC;QAC3B,uBAAuB,EAAE,OAAO,CAAC;KAClC,CAAC;CACH;AAED,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,WAAW,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;CACnC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,yBAAyB,GACjC,sBAAsB,CAuGxB;AAkED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,qBAAqB,CAAC;IAC9B,SAAS,EAAE,sBAAsB,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAKD,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,sBAAsB,GAChC,MAAM,CAWR;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,GAClB,uBAAuB,GAAG,IAAI,CAQhC"}

package/dist/project-shape.js

@@ -0,0 +1,212 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+/**
+ * Coarse project-shape classification. Drives the default
+ * surface composition: a single-app repo hides monorepo-only
+ * commands by default; a library repo hides app-only commands.
+ */
+export var ProjectShape;
+(function (ProjectShape) {
+    ProjectShape["SingleApp"] = "single-app";
+    ProjectShape["AppWithLibs"] = "app-with-libs";
+    ProjectShape["Monorepo"] = "monorepo";
+    ProjectShape["Library"] = "library";
+    ProjectShape["Unknown"] = "unknown";
+})(ProjectShape || (ProjectShape = {}));
+/**
+ * Deterministic project-shape detector. No AI, no heuristics
+ * beyond file/dependency presence. Result is cacheable.
+ *
+ * Rules (first match wins; subsequent signals contribute evidence
+ * but do not change the verdict):
+ *
+ *   1. `nx.json` present AND ≥6 Nx projects discovered → Monorepo.
+ *   2. `package.json workspaces` field with ≥3 entries → Monorepo.
+ *   3. `angular.json` workspace with exactly one project → SingleApp.
+ *   4. `apps/` AND `libs/` dirs present (Nx-style) → AppWithLibs.
+ *   5. `package.json` with build/test scripts but NO dev/serve/start
+ *      script AND no app dir → Library.
+ *   6. Otherwise → Unknown.
+ */
+export function detectProjectShape(options) {
+    const { projectRoot, packageJson } = options;
+    const evidence = [];
+    const signals = {
+        hasAngularJson: existsSync(nodePath.join(projectRoot, 'angular.json')),
+        hasNxJson: existsSync(nodePath.join(projectRoot, 'nx.json')),
+        nxProjectCount: null,
+        workspaceCount: null,
+        hasAppsDir: existsSync(nodePath.join(projectRoot, 'apps')),
+        hasLibsDir: existsSync(nodePath.join(projectRoot, 'libs')),
+        hasDevServeScript: false,
+        hasOnlyBuildTestScripts: false,
+    };
+    // Nx project count (best-effort: read nx.json + count projects/).
+    if (signals.hasNxJson) {
+        signals.nxProjectCount = countNxProjects(projectRoot);
+        if (signals.nxProjectCount !== null) {
+            evidence.push(`nx.json present (${signals.nxProjectCount} projects)`);
+        }
+        else {
+            evidence.push('nx.json present');
+        }
+    }
+    // Workspaces count.
+    if (packageJson?.workspaces !== undefined) {
+        const ws = packageJson.workspaces;
+        const list = Array.isArray(ws) ? ws : (ws.packages ?? []);
+        signals.workspaceCount = list.length;
+        evidence.push(`package.json workspaces (${list.length} entries)`);
+    }
+    // Angular detection.
+    if (signals.hasAngularJson) {
+        evidence.push('angular.json present');
+    }
+    // Script-based signals.
+    const scripts = packageJson?.scripts ?? {};
+    const scriptNames = Object.keys(scripts);
+    signals.hasDevServeScript = scriptNames.some((s) => ['dev', 'serve', 'start'].includes(s));
+    signals.hasOnlyBuildTestScripts =
+        scriptNames.length > 0 &&
+            scriptNames.every((s) => /^(build|test|lint|format|prepublish|prepare)/.test(s));
+    if (signals.hasAppsDir)
+        evidence.push('apps/ directory');
+    if (signals.hasLibsDir)
+        evidence.push('libs/ directory');
+    if (signals.hasDevServeScript)
+        evidence.push('dev/serve/start script');
+    if (signals.hasOnlyBuildTestScripts)
+        evidence.push('only build/test scripts');
+    // Count workspaces-glob packages on disk (cheap dir count for
+    // `packages/`, `libs/`, `apps/` — a glob like `packages/*` matches
+    // any direct subdir).
+    const packagesDirCount = countDirectChildren(nodePath.join(projectRoot, 'packages'));
+    if (packagesDirCount > 0) {
+        evidence.push(`packages/ (${packagesDirCount} entries)`);
+    }
+    // Apply rules — strongest signals first. Conservative on SingleApp:
+    // require an unambiguous app signal (angular.json single project, or
+    // a dev script in a project with NO sibling packages and NO nx.json
+    // and NO workspaces field).
+    if (signals.hasNxJson && (signals.nxProjectCount ?? 0) >= 6) {
+        return { shape: ProjectShape.Monorepo, evidence, signals };
+    }
+    if ((signals.workspaceCount ?? 0) >= 3) {
+        return { shape: ProjectShape.Monorepo, evidence, signals };
+    }
+    if (signals.hasNxJson && packagesDirCount >= 6) {
+        return { shape: ProjectShape.Monorepo, evidence, signals };
+    }
+    if ((signals.workspaceCount ?? 0) >= 1 &&
+        packagesDirCount >= 3) {
+        return { shape: ProjectShape.Monorepo, evidence, signals };
+    }
+    if (signals.hasAngularJson) {
+        const projectCount = countAngularProjects(projectRoot);
+        if (projectCount !== null && projectCount > 1) {
+            evidence.push(`angular.json (${projectCount} projects)`);
+            return { shape: ProjectShape.AppWithLibs, evidence, signals };
+        }
+        return { shape: ProjectShape.SingleApp, evidence, signals };
+    }
+    if (signals.hasAppsDir && signals.hasLibsDir) {
+        return { shape: ProjectShape.AppWithLibs, evidence, signals };
+    }
+    if (signals.hasOnlyBuildTestScripts && !signals.hasAppsDir && packagesDirCount === 0) {
+        return { shape: ProjectShape.Library, evidence, signals };
+    }
+    if (signals.hasDevServeScript &&
+        !signals.hasLibsDir &&
+        !signals.hasNxJson &&
+        signals.workspaceCount === null &&
+        packagesDirCount === 0) {
+        return { shape: ProjectShape.SingleApp, evidence, signals };
+    }
+    return { shape: ProjectShape.Unknown, evidence, signals };
+}
+function countDirectChildren(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function countNxProjects(projectRoot) {
+    // Best-effort: count entries in nx.json `projects` (legacy) or count
+    // `project.json` files. Avoid recursing the whole tree; cap depth.
+    const nxFile = nodePath.join(projectRoot, 'nx.json');
+    try {
+        const nx = JSON.parse(readFileSync(nxFile, 'utf8'));
+        if (nx.projects && typeof nx.projects === 'object') {
+            return Object.keys(nx.projects).length;
+        }
+    }
+    catch {
+        // ignore
+    }
+    // Fallback: look in apps/ + libs/ for project.json sentinels.
+    let count = 0;
+    for (const root of ['apps', 'libs', 'packages']) {
+        const dir = nodePath.join(projectRoot, root);
+        if (!existsSync(dir))
+            continue;
+        try {
+            const entries = readJsonChildren(dir);
+            count += entries;
+        }
+        catch {
+            // ignore
+        }
+    }
+    return count > 0 ? count : null;
+}
+function countAngularProjects(projectRoot) {
+    try {
+        const angularJson = JSON.parse(readFileSync(nodePath.join(projectRoot, 'angular.json'), 'utf8'));
+        if (angularJson.projects && typeof angularJson.projects === 'object') {
+            return Object.keys(angularJson.projects).length;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+function readJsonChildren(dir) {
+    let count = 0;
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+        if (e.isDirectory()) {
+            const projectJson = nodePath.join(dir, e.name, 'project.json');
+            if (existsSync(projectJson))
+                count += 1;
+        }
+    }
+    return count;
+}
+const CACHE_DIR = '.sharkcraft';
+const CACHE_FILE = 'shape.json';
+export function cacheProjectShape(projectRoot, detection) {
+    const dir = nodePath.join(projectRoot, CACHE_DIR);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const file = nodePath.join(dir, CACHE_FILE);
+    const entry = {
+        schema: 'sharkcraft.shape.v1',
+        detection,
+        cachedAt: new Date().toISOString(),
+    };
+    writeFileSync(file, JSON.stringify(entry, null, 2) + '\n', 'utf8');
+    return file;
+}
+export function readCachedProjectShape(projectRoot) {
+    const file = nodePath.join(projectRoot, CACHE_DIR, CACHE_FILE);
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/tsconfig-reader.d.ts

@@ -0,0 +1,12 @@
+import { type AppError, type Result } from '@shrkcrft/core';
+export interface ITsConfig {
+    target?: string;
+    module?: string;
+    strict?: boolean;
+    paths?: Record<string, string[]>;
+    baseUrl?: string;
+    extends?: string;
+    raw: Record<string, unknown>;
+}
+export declare function readTsConfig(projectRoot: string): Result<ITsConfig | null, AppError>;
+//# sourceMappingURL=tsconfig-reader.d.ts.map

package/dist/tsconfig-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsconfig-reader.d.ts","sourceRoot":"","sources":["../src/tsconfig-reader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAsC,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAEhG,MAAM,WAAW,SAAS;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9B;AAID,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC,SAAS,GAAG,IAAI,EAAE,QAAQ,CAAC,CAiCpF"}

package/dist/tsconfig-reader.js

@@ -0,0 +1,37 @@
+import { existsSync, readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { AppErrorImpl, ERROR_CODES, err, ok } from '@shrkcrft/core';
+const TSCONFIG_NAMES = ['tsconfig.json', 'tsconfig.base.json'];
+export function readTsConfig(projectRoot) {
+    for (const name of TSCONFIG_NAMES) {
+        const file = nodePath.join(projectRoot, name);
+        if (existsSync(file)) {
+            try {
+                const text = readFileSync(file, 'utf8');
+                // strip // comments and trailing commas to handle JSON-with-comments tsconfigs
+                const cleaned = text
+                    .replace(/\/\*[\s\S]*?\*\//g, '')
+                    .replace(/(^|[^:\\])\/\/.*$/gm, '$1')
+                    .replace(/,(\s*[}\]])/g, '$1');
+                const parsed = JSON.parse(cleaned);
+                const compilerOptions = parsed.compilerOptions ?? {};
+                return ok({
+                    target: compilerOptions.target,
+                    module: compilerOptions.module,
+                    strict: compilerOptions.strict,
+                    paths: compilerOptions.paths,
+                    baseUrl: compilerOptions.baseUrl,
+                    extends: parsed.extends,
+                    raw: parsed,
+                });
+            }
+            catch (e) {
+                return err(new AppErrorImpl(ERROR_CODES.FILE_READ_ERROR, `Failed to parse ${name}: ${file}`, {
+                    details: { file },
+                    cause: e,
+                }));
+            }
+        }
+    }
+    return ok(null);
+}

package/dist/workspace-inspector.d.ts

@@ -0,0 +1,7 @@
+import type { IWorkspaceSummary } from './workspace-summary.js';
+export interface InspectWorkspaceOptions {
+    startDir?: string;
+    sharkcraftDirName?: string;
+}
+export declare function inspectWorkspace(options?: InspectWorkspaceOptions): Promise<IWorkspaceSummary>;
+//# sourceMappingURL=workspace-inspector.d.ts.map

package/dist/workspace-inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-inspector.d.ts","sourceRoot":"","sources":["../src/workspace-inspector.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAsB,gBAAgB,CACpC,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,iBAAiB,CAAC,CA0C5B"}

package/dist/workspace-inspector.js

@@ -0,0 +1,57 @@
+import { existsSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { detectProjectRoot } from "./project-root-detector.js";
+import { readPackageJson } from "./package-json-reader.js";
+import { detectPackageManager } from "./package-manager-detector.js";
+import { detectFrameworks } from "./framework-detector.js";
+import { readTsConfig } from "./tsconfig-reader.js";
+import { listTopLevelDirs } from "./folder-scanner.js";
+import { detectProfiles } from "./profile-detector.js";
+export async function inspectWorkspace(options = {}) {
+    const startDir = options.startDir ?? process.cwd();
+    const sharkcraftDirName = options.sharkcraftDirName ?? 'sharkcraft';
+    const { root } = detectProjectRoot(startDir);
+    const pkgResult = readPackageJson(root);
+    const pkg = pkgResult.ok ? pkgResult.value : null;
+    const pkgManager = detectPackageManager(root, pkg);
+    const frameworks = detectFrameworks(root, pkg);
+    const tsConfigResult = readTsConfig(root);
+    const tsConfig = tsConfigResult.ok ? tsConfigResult.value : null;
+    const sharkcraftPath = nodePath.join(root, sharkcraftDirName);
+    const hasSharkcraftFolder = existsSync(sharkcraftPath) && safeIsDir(sharkcraftPath);
+    const topLevelDirs = listTopLevelDirs(root);
+    const profileResult = detectProfiles({
+        packageJson: pkg,
+        frameworks,
+        topLevelDirs,
+        hasTsConfig: tsConfig !== null,
+    });
+    return {
+        projectRoot: root,
+        hasPackageJson: pkg !== null,
+        packageName: pkg?.name,
+        packageVersion: pkg?.version,
+        description: pkg?.description,
+        packageManager: pkgManager,
+        frameworks,
+        hasTypeScript: frameworks.some((f) => f.id === 'typescript') || tsConfig !== null,
+        tsConfig,
+        scripts: pkg?.scripts ?? {},
+        dependencies: pkg?.dependencies ?? {},
+        devDependencies: pkg?.devDependencies ?? {},
+        topLevelDirs,
+        hasSharkcraftFolder,
+        sharkcraftPath: hasSharkcraftFolder ? sharkcraftPath : null,
+        profiles: profileResult.profiles,
+        profileEvidence: profileResult.evidence,
+        raw: { packageJson: pkg },
+    };
+}
+function safeIsDir(p) {
+    try {
+        return statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/workspace-summary.d.ts

@@ -0,0 +1,29 @@
+import type { IPackageJson } from './package-json-reader.js';
+import type { IPackageManagerInfo } from './package-manager-detector.js';
+import type { IFrameworkInfo } from './framework-detector.js';
+import type { ITsConfig } from './tsconfig-reader.js';
+import type { IProfileDetectionResult, WorkspaceProfile } from './profile-detector.js';
+export interface IWorkspaceSummary {
+    projectRoot: string;
+    hasPackageJson: boolean;
+    packageName?: string;
+    packageVersion?: string;
+    description?: string;
+    packageManager: IPackageManagerInfo;
+    frameworks: IFrameworkInfo[];
+    hasTypeScript: boolean;
+    tsConfig: ITsConfig | null;
+    scripts: Record<string, string>;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    topLevelDirs: string[];
+    hasSharkcraftFolder: boolean;
+    sharkcraftPath: string | null;
+    /** Inferred profile tags (see WorkspaceProfile). */
+    profiles: readonly WorkspaceProfile[];
+    profileEvidence: IProfileDetectionResult['evidence'];
+    raw: {
+        packageJson: IPackageJson | null;
+    };
+}
+//# sourceMappingURL=workspace-summary.d.ts.map

package/dist/workspace-summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-summary.d.ts","sourceRoot":"","sources":["../src/workspace-summary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEvF,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,mBAAmB,CAAC;IACpC,UAAU,EAAE,cAAc,EAAE,CAAC;IAC7B,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,oDAAoD;IACpD,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACtC,eAAe,EAAE,uBAAuB,CAAC,UAAU,CAAC,CAAC;IACrD,GAAG,EAAE;QAAE,WAAW,EAAE,YAAY,GAAG,IAAI,CAAA;KAAE,CAAC;CAC3C"}

package/dist/workspace-summary.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@shrkcrft/workspace",
+  "version": "0.1.0-alpha.2",
+  "description": "SharkCraft workspace inspector: project root, package.json, package manager, frameworks, tsconfig.",
+  "license": "MIT",
+  "author": "SharkCraft contributors",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shrkcrft/sharkcraft.git",
+    "directory": "packages/workspace"
+  },
+  "homepage": "https://github.com/shrkcrft/sharkcraft",
+  "bugs": {
+    "url": "https://github.com/shrkcrft/sharkcraft/issues"
+  },
+  "keywords": [
+    "sharkcraft",
+    "workspace",
+    "project-root",
+    "frameworks"
+  ],
+  "engines": {
+    "bun": ">=1.1.0",
+    "node": ">=18"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@shrkcrft/core": "^0.1.0-alpha.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}