@shrkcrft/inspector 0.1.0-alpha.1

package/dist/languages/language-boundaries.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Polyglot boundary suggestions.
+ *
+ * Produces *suggested* boundary rules per detected language. These are
+ * conservative defaults (Java domain→infra, Python domain→web framework, …)
+ * surfaced via `shrk boundaries infer --language all`. The user reviews and
+ * copies keepers into `sharkcraft/boundaries.ts`. The existing TS-aware
+ * boundary engine is unchanged.
+ */
+import { LanguageId } from './language-id.js';
+export interface ILanguageBoundarySuggestion {
+    id: string;
+    title: string;
+    severity: 'error' | 'warning';
+    language: LanguageId;
+    fromGlob: string;
+    forbiddenImports: readonly string[];
+    reason: string;
+    example: string;
+}
+export interface ILanguageBoundarySuggestionReport {
+    generatedAt: string;
+    projectRoot: string;
+    suggestions: readonly ILanguageBoundarySuggestion[];
+    notes: readonly string[];
+}
+export declare function suggestLanguageBoundaries(projectRoot: string, options?: {
+    language?: LanguageId;
+}): ILanguageBoundarySuggestionReport;
+//# sourceMappingURL=language-boundaries.d.ts.map

package/dist/languages/language-boundaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-boundaries.d.ts","sourceRoot":"","sources":["../../src/languages/language-boundaries.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,MAAM,WAAW,2BAA2B;IAC1C,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,QAAQ,EAAE,UAAU,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iCAAiC;IAChD,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,SAAS,2BAA2B,EAAE,CAAC;IACpD,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AAiJD,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,UAAU,CAAA;CAAO,GACtC,iCAAiC,CAoBnC"}

package/dist/languages/language-boundaries.js

@@ -0,0 +1,176 @@
+/**
+ * Polyglot boundary suggestions.
+ *
+ * Produces *suggested* boundary rules per detected language. These are
+ * conservative defaults (Java domain→infra, Python domain→web framework, …)
+ * surfaced via `shrk boundaries infer --language all`. The user reviews and
+ * copies keepers into `sharkcraft/boundaries.ts`. The existing TS-aware
+ * boundary engine is unchanged.
+ */
+import { LanguageId } from "./language-id.js";
+import { detectLanguageProfiles } from "./language-detection.js";
+function javaSuggestions(profile) {
+    const out = [];
+    out.push({
+        id: 'java.controller-not-importing-repository',
+        title: 'Controllers should not import repositories directly',
+        severity: 'warning',
+        language: LanguageId.Java,
+        fromGlob: '**/controller/**',
+        forbiddenImports: ['*.repository.*', '*.dao.*'],
+        reason: 'Routing layer should depend on service layer, not on persistence directly.',
+        example: 'src/main/java/com/foo/controller/UserController.java importing com.foo.repository.UserRepository',
+    });
+    out.push({
+        id: 'java.domain-not-importing-infrastructure',
+        title: 'Domain must not import infrastructure',
+        severity: 'error',
+        language: LanguageId.Java,
+        fromGlob: '**/domain/**',
+        forbiddenImports: ['*.infrastructure.*', '*.config.*'],
+        reason: 'Domain stays independent of frameworks / database / IO.',
+        example: 'com.foo.domain.User importing com.foo.infrastructure.UserRepositoryImpl',
+    });
+    if (profile.frameworkSignals.includes('spring-boot')) {
+        out.push({
+            id: 'java.domain-not-importing-springboot',
+            title: 'Domain should not import Spring',
+            severity: 'warning',
+            language: LanguageId.Java,
+            fromGlob: '**/domain/**',
+            forbiddenImports: ['org.springframework.*'],
+            reason: 'Keep domain framework-agnostic.',
+            example: 'com.foo.domain.* importing org.springframework.*',
+        });
+    }
+    return out;
+}
+function csharpSuggestions(profile) {
+    const out = [];
+    out.push({
+        id: 'csharp.domain-not-depending-on-infrastructure',
+        title: 'Domain project must not depend on Infrastructure / Web',
+        severity: 'error',
+        language: LanguageId.CSharp,
+        fromGlob: '**/Domain/**',
+        forbiddenImports: ['*.Infrastructure.*', '*.Web.*'],
+        reason: 'Onion / Clean architecture: outer layers depend inward.',
+        example: 'Domain.Foo importing Infrastructure.Repositories.FooRepository',
+    });
+    out.push({
+        id: 'csharp.web-not-depending-on-domain-directly',
+        title: 'Web project depends on Application, not Domain',
+        severity: 'warning',
+        language: LanguageId.CSharp,
+        fromGlob: '**/Web/**',
+        forbiddenImports: ['*.Domain.*'],
+        reason: 'Application orchestrates Domain; Web should not call Domain directly.',
+        example: 'Web.Controllers.UserController importing Domain.Entities.User',
+    });
+    void profile;
+    return out;
+}
+function pythonSuggestions(profile) {
+    const out = [];
+    const webFramework = ['fastapi', 'django', 'flask'].filter((f) => profile.frameworkSignals.includes(f));
+    if (webFramework.length > 0) {
+        out.push({
+            id: 'python.domain-not-importing-web-framework',
+            title: `Domain must not import ${webFramework.join(' / ')}`,
+            severity: 'error',
+            language: LanguageId.Python,
+            fromGlob: '**/domain/**',
+            forbiddenImports: webFramework,
+            reason: 'Domain stays framework-agnostic.',
+            example: 'domain/user.py importing fastapi.FastAPI',
+        });
+    }
+    out.push({
+        id: 'python.app-not-importing-tests',
+        title: 'Application code must not import tests',
+        severity: 'error',
+        language: LanguageId.Python,
+        fromGlob: 'src/**',
+        forbiddenImports: ['tests.*', 'test_*'],
+        reason: 'Production code must not depend on the test tree.',
+        example: 'src/foo.py importing tests.fixtures.user_fixture',
+    });
+    return out;
+}
+function goSuggestions(profile) {
+    const out = [];
+    out.push({
+        id: 'go.no-importing-internal-from-outside',
+        title: 'Packages outside parent must not import `internal/`',
+        severity: 'error',
+        language: LanguageId.Go,
+        fromGlob: '**/*.go',
+        forbiddenImports: ['*/internal/*'],
+        reason: 'Go enforces the same rule at compile time; the boundary surfaces it earlier.',
+        example: 'pkg/foo/foo.go importing github.com/other-module/internal/bar',
+    });
+    out.push({
+        id: 'go.pkg-not-importing-cmd',
+        title: 'pkg should not import cmd',
+        severity: 'warning',
+        language: LanguageId.Go,
+        fromGlob: 'pkg/**',
+        forbiddenImports: ['*/cmd/*'],
+        reason: 'cmd/ is the entry point; library code should not depend on it.',
+        example: 'pkg/foo.go importing example.com/repo/cmd/main',
+    });
+    void profile;
+    return out;
+}
+function rustSuggestions(profile) {
+    const out = [];
+    out.push({
+        id: 'rust.lib-not-importing-bin',
+        title: 'Library crate should not depend on bin-only modules',
+        severity: 'warning',
+        language: LanguageId.Rust,
+        fromGlob: 'src/lib.rs',
+        forbiddenImports: ['crate::bin::*'],
+        reason: 'Libraries should be reusable; bin modules are entry points.',
+        example: 'src/lib.rs `use crate::bin::main_helper;`',
+    });
+    out.push({
+        id: 'rust.crate-not-importing-tests',
+        title: 'Crate code must not import the tests/ tree',
+        severity: 'error',
+        language: LanguageId.Rust,
+        fromGlob: 'src/**',
+        forbiddenImports: ['tests::*'],
+        reason: 'Production code must not depend on the test tree.',
+        example: 'src/foo.rs `use tests::fixtures::user;`',
+    });
+    void profile;
+    return out;
+}
+export function suggestLanguageBoundaries(projectRoot, options = {}) {
+    const report = detectLanguageProfiles(projectRoot);
+    const out = [];
+    for (const p of report.profiles) {
+        if (options.language && p.language !== options.language)
+            continue;
+        if (p.language === LanguageId.Java)
+            out.push(...javaSuggestions(p));
+        else if (p.language === LanguageId.CSharp)
+            out.push(...csharpSuggestions(p));
+        else if (p.language === LanguageId.Python)
+            out.push(...pythonSuggestions(p));
+        else if (p.language === LanguageId.Go)
+            out.push(...goSuggestions(p));
+        else if (p.language === LanguageId.Rust)
+            out.push(...rustSuggestions(p));
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        projectRoot,
+        suggestions: out,
+        notes: [
+            'Suggestions only. Copy keepers into sharkcraft/boundaries.ts manually.',
+            'These boundaries describe *intent*; the engine itself remains TS-aware.',
+        ],
+    };
+}

package/dist/languages/language-cache.d.ts

@@ -0,0 +1,54 @@
+import { type ILanguageProfileReport } from './language-detection.js';
+export declare const LANGUAGE_CACHE_SCHEMA = "sharkcraft.language-cache/v1";
+export interface ILanguageCacheSignature {
+    projectRoot: string;
+    sharkcraftVersion: string;
+    manifestSignatures: Readonly<Record<string, {
+        mtimeMs: number;
+        sizeBytes: number;
+    }>>;
+    extensionStats: Readonly<Record<string, {
+        fileCount: number;
+        latestMtimeMs: number;
+    }>>;
+}
+export interface ILanguageProfileCache {
+    schema: typeof LANGUAGE_CACHE_SCHEMA;
+    signature: ILanguageCacheSignature;
+    report: ILanguageProfileReport;
+    cachedAt: string;
+}
+export interface ILanguageCacheStatus {
+    schema: typeof LANGUAGE_CACHE_SCHEMA;
+    projectRoot: string;
+    cacheFile: string;
+    exists: boolean;
+    cachedAt?: string;
+    fresh: boolean;
+    staleReasons: readonly string[];
+}
+export declare function computeLanguageCacheSignature(projectRoot: string, sharkcraftVersion: string): ILanguageCacheSignature;
+export declare function loadLanguageCache(projectRoot: string): ILanguageProfileCache | null;
+export declare function saveLanguageCache(cache: ILanguageProfileCache): void;
+export interface IDetectLanguagesWithCacheOptions {
+    projectRoot: string;
+    sharkcraftVersion: string;
+    /** When true, attempt to use the cache (default: true if call site asks). */
+    useCache?: boolean;
+    /** When true, refresh and overwrite the cache after running detection. */
+    refresh?: boolean;
+}
+export interface IDetectLanguagesWithCacheResult {
+    report: ILanguageProfileReport;
+    cacheHit: boolean;
+    staleReasons: readonly string[];
+}
+export declare function detectLanguageProfilesWithCache(options: IDetectLanguagesWithCacheOptions): IDetectLanguagesWithCacheResult;
+export declare function getLanguageCacheStatus(projectRoot: string, sharkcraftVersion: string): ILanguageCacheStatus;
+export declare function clearLanguageCache(projectRoot: string, options?: {
+    write?: boolean;
+}): {
+    cleared: boolean;
+    cacheFile: string;
+};
+//# sourceMappingURL=language-cache.d.ts.map

package/dist/languages/language-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-cache.d.ts","sourceRoot":"","sources":["../../src/languages/language-cache.ts"],"names":[],"mappings":"AAmBA,OAAO,EAA0B,KAAK,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAE9F,eAAO,MAAM,qBAAqB,iCAAiC,CAAC;AAEpE,MAAM,WAAW,uBAAuB;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;IACrF,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;CACxF;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,OAAO,qBAAqB,CAAC;IACrC,SAAS,EAAE,uBAAuB,CAAC;IACnC,MAAM,EAAE,sBAAsB,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,OAAO,qBAAqB,CAAC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC;AAqFD,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,MAAM,EACnB,iBAAiB,EAAE,MAAM,GACxB,uBAAuB,CAYzB;AA4BD,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAYnF;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,qBAAqB,GAAG,IAAI,CAIpE;AAED,MAAM,WAAW,gCAAgC;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,+BAA+B;IAC9C,MAAM,EAAE,sBAAsB,CAAC;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,gCAAgC,GACxC,+BAA+B,CA2BjC;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,iBAAiB,EAAE,MAAM,GACxB,oBAAoB,CAwBtB;AAED,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAQlI"}

package/dist/languages/language-cache.js

@@ -0,0 +1,236 @@
+/**
+ * Language profile cache.
+ *
+ * Caches the most-recent `ILanguageProfileReport` under
+ * `.sharkcraft/languages/cache.json` so large repos don't re-walk the tree
+ * on every `shrk languages detect`. Opt-in: cache is only used when the
+ * caller passes `--cache` (or `useCache: true`).
+ *
+ * Cache key signature:
+ *  - project root absolute path
+ *  - SharkCraft pkg version (caller-provided)
+ *  - mtime + sizeBytes per known manifest file
+ *  - file count + latest mtime per relevant extension
+ *
+ * Stale-cache rule: any mismatch on the signature returns the cached value
+ * but flags it as stale; callers can decide to recompute.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { detectLanguageProfiles } from "./language-detection.js";
+export const LANGUAGE_CACHE_SCHEMA = 'sharkcraft.language-cache/v1';
+const CACHE_REL_PATH = nodePath.join('.sharkcraft', 'languages', 'cache.json');
+const MANIFEST_FILES = [
+    'package.json',
+    'tsconfig.json',
+    'bun.lockb',
+    'pnpm-lock.yaml',
+    'yarn.lock',
+    'package-lock.json',
+    'pom.xml',
+    'build.gradle',
+    'build.gradle.kts',
+    'settings.gradle',
+    'settings.gradle.kts',
+    'pyproject.toml',
+    'requirements.txt',
+    'setup.py',
+    'poetry.lock',
+    'uv.lock',
+    'go.mod',
+    'go.sum',
+    'Cargo.toml',
+    'Cargo.lock',
+];
+const TRACKED_EXTENSIONS = ['.ts', '.tsx', '.js', '.java', '.cs', '.py', '.go', '.rs'];
+function cachePathFor(projectRoot) {
+    return nodePath.join(projectRoot, CACHE_REL_PATH);
+}
+function statManifest(projectRoot, name) {
+    const abs = nodePath.join(projectRoot, name);
+    if (!existsSync(abs))
+        return null;
+    try {
+        const st = statSync(abs);
+        return { mtimeMs: Math.floor(st.mtimeMs), sizeBytes: st.size };
+    }
+    catch {
+        return null;
+    }
+}
+function buildExtensionStats(projectRoot) {
+    const out = {};
+    for (const ext of TRACKED_EXTENSIONS)
+        out[ext] = { fileCount: 0, latestMtimeMs: 0 };
+    const stack = [projectRoot];
+    const ignored = new Set(['node_modules', '.git', 'target', 'build', 'bin', 'obj', 'dist', 'out', '__pycache__', '.venv', 'venv', 'vendor', '.idea', '.vscode']);
+    while (stack.length > 0) {
+        const cur = stack.pop();
+        let entries;
+        try {
+            entries = readdirSync(cur);
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (ignored.has(e))
+                continue;
+            const abs = nodePath.join(cur, e);
+            let st;
+            try {
+                st = statSync(abs);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                stack.push(abs);
+                continue;
+            }
+            if (!st.isFile())
+                continue;
+            const lower = e.toLowerCase();
+            for (const ext of TRACKED_EXTENSIONS) {
+                if (lower.endsWith(ext)) {
+                    const bucket = out[ext];
+                    bucket.fileCount += 1;
+                    if (st.mtimeMs > bucket.latestMtimeMs)
+                        bucket.latestMtimeMs = Math.floor(st.mtimeMs);
+                    break;
+                }
+            }
+        }
+    }
+    return out;
+}
+export function computeLanguageCacheSignature(projectRoot, sharkcraftVersion) {
+    const manifestSignatures = {};
+    for (const name of MANIFEST_FILES) {
+        const s = statManifest(projectRoot, name);
+        if (s)
+            manifestSignatures[name] = s;
+    }
+    return {
+        projectRoot,
+        sharkcraftVersion,
+        manifestSignatures,
+        extensionStats: buildExtensionStats(projectRoot),
+    };
+}
+function signaturesEqual(a, b) {
+    const issues = [];
+    if (a.projectRoot !== b.projectRoot)
+        issues.push(`projectRoot mismatch (${a.projectRoot} vs ${b.projectRoot})`);
+    if (a.sharkcraftVersion !== b.sharkcraftVersion)
+        issues.push(`SharkCraft version drift (${a.sharkcraftVersion} vs ${b.sharkcraftVersion})`);
+    const allManifest = new Set([...Object.keys(a.manifestSignatures), ...Object.keys(b.manifestSignatures)]);
+    for (const name of allManifest) {
+        const x = a.manifestSignatures[name];
+        const y = b.manifestSignatures[name];
+        if (!x || !y) {
+            issues.push(`manifest ${name} added/removed`);
+            continue;
+        }
+        if (x.mtimeMs !== y.mtimeMs || x.sizeBytes !== y.sizeBytes) {
+            issues.push(`manifest ${name} changed (mtime/size)`);
+        }
+    }
+    for (const ext of TRACKED_EXTENSIONS) {
+        const x = a.extensionStats[ext];
+        const y = b.extensionStats[ext];
+        if (!x || !y)
+            continue;
+        if (x.fileCount !== y.fileCount)
+            issues.push(`*${ext} file count drift (${x.fileCount} → ${y.fileCount})`);
+        else if (Math.abs(x.latestMtimeMs - y.latestMtimeMs) > 1)
+            issues.push(`*${ext} latest mtime drift`);
+    }
+    return issues;
+}
+export function loadLanguageCache(projectRoot) {
+    const file = cachePathFor(projectRoot);
+    if (!existsSync(file))
+        return null;
+    try {
+        const raw = readFileSync(file, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object')
+            return null;
+        if (parsed.schema !== LANGUAGE_CACHE_SCHEMA)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveLanguageCache(cache) {
+    const file = cachePathFor(cache.signature.projectRoot);
+    mkdirSync(nodePath.dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(cache, null, 2), 'utf8');
+}
+export function detectLanguageProfilesWithCache(options) {
+    const signature = computeLanguageCacheSignature(options.projectRoot, options.sharkcraftVersion);
+    if (options.useCache !== false) {
+        const cached = loadLanguageCache(options.projectRoot);
+        if (cached) {
+            const issues = signaturesEqual(signature, cached.signature);
+            if (issues.length === 0) {
+                return { report: cached.report, cacheHit: true, staleReasons: [] };
+            }
+            if (!options.refresh) {
+                return { report: cached.report, cacheHit: true, staleReasons: issues };
+            }
+        }
+    }
+    const report = detectLanguageProfiles(options.projectRoot);
+    const next = {
+        schema: LANGUAGE_CACHE_SCHEMA,
+        signature,
+        report,
+        cachedAt: new Date().toISOString(),
+    };
+    try {
+        saveLanguageCache(next);
+    }
+    catch {
+        // ignore write failures — cache is best-effort.
+    }
+    return { report, cacheHit: false, staleReasons: [] };
+}
+export function getLanguageCacheStatus(projectRoot, sharkcraftVersion) {
+    const file = cachePathFor(projectRoot);
+    const cached = loadLanguageCache(projectRoot);
+    if (!cached) {
+        return {
+            schema: LANGUAGE_CACHE_SCHEMA,
+            projectRoot,
+            cacheFile: file,
+            exists: false,
+            fresh: false,
+            staleReasons: [],
+        };
+    }
+    const signature = computeLanguageCacheSignature(projectRoot, sharkcraftVersion);
+    const issues = signaturesEqual(signature, cached.signature);
+    return {
+        schema: LANGUAGE_CACHE_SCHEMA,
+        projectRoot,
+        cacheFile: file,
+        exists: true,
+        cachedAt: cached.cachedAt,
+        fresh: issues.length === 0,
+        staleReasons: issues,
+    };
+}
+export function clearLanguageCache(projectRoot, options = {}) {
+    const file = cachePathFor(projectRoot);
+    if (!options.write)
+        return { cleared: false, cacheFile: file };
+    if (existsSync(file)) {
+        rmSync(file, { force: true });
+        return { cleared: true, cacheFile: file };
+    }
+    return { cleared: false, cacheFile: file };
+}

package/dist/languages/language-detection.d.ts

@@ -0,0 +1,30 @@
+import { LanguageId } from './language-id.js';
+export declare const LANGUAGE_PROFILE_SCHEMA = "sharkcraft.language-profile/v1";
+export interface ILanguageProfile {
+    schema: typeof LANGUAGE_PROFILE_SCHEMA;
+    language: LanguageId;
+    confidence: 'low' | 'medium' | 'high';
+    fileCount: number;
+    sourceRoots: readonly string[];
+    testRoots: readonly string[];
+    buildFiles: readonly string[];
+    dependencyFiles: readonly string[];
+    packageManager?: string;
+    buildTool?: string;
+    testFrameworks: readonly string[];
+    frameworkSignals: readonly string[];
+    likelyCommands: readonly string[];
+    riskNotes: readonly string[];
+}
+export interface ILanguageProfileReport {
+    schema: typeof LANGUAGE_PROFILE_SCHEMA;
+    generatedAt: string;
+    projectRoot: string;
+    dominantLanguage: LanguageId;
+    profiles: readonly ILanguageProfile[];
+    warnings: readonly string[];
+}
+export declare function detectLanguageProfiles(projectRoot: string): ILanguageProfileReport;
+export declare function renderLanguageProfilesText(r: ILanguageProfileReport): string;
+export declare function renderLanguageProfilesMarkdown(r: ILanguageProfileReport): string;
+//# sourceMappingURL=language-detection.d.ts.map

package/dist/languages/language-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-detection.d.ts","sourceRoot":"","sources":["../../src/languages/language-detection.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,eAAO,MAAM,uBAAuB,mCAAmC,CAAC;AAExE,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,uBAAuB,CAAC;IACvC,QAAQ,EAAE,UAAU,CAAC;IACrB,UAAU,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,OAAO,uBAAuB,CAAC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,UAAU,CAAC;IAC7B,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACtC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B;AAyaD,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,sBAAsB,CAgClF;AAED,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAuB5E;AAED,wBAAgB,8BAA8B,CAAC,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAoBhF"}