forkit-ai-footprints 0.2.0

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/evaluate.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectMacosMajorVersion = detectMacosMajorVersion;
+exports.evaluateMacosFieldTruth = evaluateMacosFieldTruth;
+exports.evaluateMacosFieldTruthFile = evaluateMacosFieldTruthFile;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const census_1 = require("./census");
+function detectMacosMajorVersion() {
+    if (process.platform !== 'darwin')
+        return null;
+    const result = (0, node_child_process_1.spawnSync)('/usr/bin/sw_vers', ['-productVersion'], {
+        encoding: 'utf8',
+        shell: false,
+        timeout: 2_000,
+    });
+    if (result.status !== 0)
+        return null;
+    const major = Number.parseInt(result.stdout.trim().split('.')[0] ?? '', 10);
+    return Number.isInteger(major) && major > 0 ? major : null;
+}
+function stringSet(value, label) {
+    if (!Array.isArray(value) || !value.every((entry) => typeof entry === 'string' && entry.length > 0)) {
+        throw new Error(`${label} must contain non-empty strings.`);
+    }
+    return new Set(value);
+}
+function score(actualInput, expectedInput) {
+    const actual = new Set(actualInput);
+    const expected = new Set(expectedInput);
+    const truePositive = [...actual].filter((value) => expected.has(value)).length;
+    const falsePositive = [...actual].filter((value) => !expected.has(value)).length;
+    const falseNegative = [...expected].filter((value) => !actual.has(value)).length;
+    return {
+        actual_count: actual.size,
+        expected_count: expected.size,
+        true_positive: truePositive,
+        false_positive: falsePositive,
+        false_negative: falseNegative,
+        precision: actual.size === 0 ? null : truePositive / actual.size,
+        recall: expected.size === 0 ? null : truePositive / expected.size,
+    };
+}
+function parseTruth(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Truth file must contain an object.');
+    const record = value;
+    if (record.schema_version !== '1.0')
+        throw new Error('Unsupported truth schema version.');
+    const expectedValue = record.expected;
+    if (!expectedValue || typeof expectedValue !== 'object' || Array.isArray(expectedValue)) {
+        throw new Error('Truth file must contain an expected object.');
+    }
+    const expected = expectedValue;
+    return {
+        schema_version: '1.0',
+        expected: {
+            agent_signatures: [...stringSet(expected.agent_signatures, 'expected.agent_signatures')],
+            tool_names: [...stringSet(expected.tool_names, 'expected.tool_names')],
+            online_runtime_names: [...stringSet(expected.online_runtime_names, 'expected.online_runtime_names')],
+            model_keys: [...stringSet(expected.model_keys, 'expected.model_keys')],
+            mcp_clients: [...stringSet(expected.mcp_clients, 'expected.mcp_clients')],
+        },
+    };
+}
+function evaluateMacosFieldTruth(truthInput, report, macosMajor = detectMacosMajorVersion()) {
+    if (report.system.platform !== 'darwin')
+        throw new Error('macOS field evaluation requires a macOS Census Report.');
+    const truth = parseTruth(truthInput);
+    return {
+        evaluation: 'macos-local-labelled-device',
+        schema_version: truth.schema_version,
+        product_version: report.product_version,
+        environment: {
+            platform: 'darwin',
+            architecture: report.system.architecture,
+            macos_major: macosMajor,
+            node_major: report.system.node_major,
+        },
+        metrics: {
+            agents: score(report.agents.map((item) => item.signature), truth.expected.agent_signatures),
+            tools: score(report.tools.map((item) => item.name), truth.expected.tool_names),
+            runtimes: score(report.runtimes.filter((item) => item.evidence_status === 'online').map((item) => item.name), truth.expected.online_runtime_names),
+            models: score(report.models.map((item) => `${item.runtime}:${item.name}`), truth.expected.model_keys),
+            mcp: score(report.mcp_configs.map((item) => item.client), truth.expected.mcp_clients),
+        },
+        uploaded: false,
+        field_accuracy_claim_allowed: false,
+    };
+}
+async function evaluateMacosFieldTruthFile(filePath) {
+    if (process.platform !== 'darwin')
+        throw new Error('macOS field evaluation must run on macOS.');
+    const content = await promises_1.default.readFile(node_path_1.default.resolve(filePath), 'utf8');
+    const truth = JSON.parse(content);
+    return evaluateMacosFieldTruth(truth, await (0, census_1.runCensus)());
+}
+//# sourceMappingURL=evaluate.js.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/filesystem.d.ts

@@ -0,0 +1,11 @@
+import type { RuntimeScanResult } from './types';
+export interface FilesystemScanOptions {
+    roots?: string[];
+    minBytes?: number;
+    maxDepth?: number;
+    maxFiles?: number;
+}
+export declare function getDefaultModelRoots(): string[];
+export declare function scanFilesystemModels(observedAt: string, input?: FilesystemScanOptions): Promise<RuntimeScanResult>;
+export declare function filesystemRootFingerprint(root: string): string;
+//# sourceMappingURL=filesystem.d.ts.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/filesystem.js

@@ -0,0 +1,226 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultModelRoots = getDefaultModelRoots;
+exports.scanFilesystemModels = scanFilesystemModels;
+exports.filesystemRootFingerprint = filesystemRootFingerprint;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const hash_1 = require("./hash");
+const base_1 = require("./providers/base");
+const MODEL_EXTENSIONS = new Set([
+    '.bin',
+    '.ggml',
+    '.gguf',
+    '.onnx',
+    '.pt',
+    '.pth',
+    '.safetensors',
+]);
+const DEFAULT_MIN_BYTES = 1;
+const DEFAULT_MAX_DEPTH = 32;
+const DEFAULT_MAX_FILES = 100_000;
+function configuredRootsFromEnvironment() {
+    return String(process.env.FORKIT_CENSUS_MODEL_DIRS ?? '')
+        .split(/[\n,]/)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function getDefaultModelRoots() {
+    const home = node_os_1.default.homedir();
+    const janData = node_path_1.default.join(home, 'Library', 'Application Support', 'Jan', 'data');
+    const xdgHuggingFaceHub = process.env.XDG_CACHE_HOME
+        ? node_path_1.default.join(process.env.XDG_CACHE_HOME, 'huggingface', 'hub')
+        : '';
+    const candidates = [
+        ...configuredRootsFromEnvironment(),
+        node_path_1.default.join(home, '.cache', 'huggingface', 'hub'),
+        node_path_1.default.join(home, '.ollama', 'models'),
+        process.env.HF_HOME ? node_path_1.default.join(process.env.HF_HOME, 'hub') : '',
+        process.env.HF_HUB_CACHE ?? '',
+        xdgHuggingFaceHub,
+        node_path_1.default.join(home, '.cache', 'lm-studio', 'models'),
+        node_path_1.default.join(home, '.lmstudio', 'models'),
+        node_path_1.default.join(janData, 'llamacpp', 'models'),
+        node_path_1.default.join(janData, 'mlx', 'models'),
+        node_path_1.default.join(home, 'models'),
+        node_path_1.default.join(home, 'model'),
+        node_path_1.default.join(home, 'ai', 'models'),
+        node_path_1.default.join(home, '.cache', 'mlx-models'),
+    ];
+    // HF_XET_CACHE is intentionally excluded: it is a transport chunk cache,
+    // not a model inventory, and counting it would duplicate model storage.
+    return [...new Set(candidates.filter(Boolean).map((entry) => node_path_1.default.resolve(entry)))];
+}
+async function directoryExists(directory) {
+    try {
+        return (await promises_1.default.stat(directory)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function huggingFaceName(relativePath) {
+    const marker = relativePath
+        .split(/[\\/]/)
+        .find((part) => part.startsWith('models--'));
+    return marker?.replace(/^models--/, '').replaceAll('--', '/') || null;
+}
+function genericModelName(relativePath) {
+    const parsed = node_path_1.default.parse(relativePath);
+    const base = parsed.name;
+    if (!['model', 'pytorch_model', 'consolidated', 'weights', 'adapter_model'].includes(base.toLowerCase())) {
+        return base.replace(/[-_.]?\d{1,5}-of-\d{1,5}$/i, '') || base;
+    }
+    return node_path_1.default.basename(parsed.dir) || base;
+}
+function ollamaStorageFile(root, relativePath) {
+    if (!root.replaceAll('\\', '/').endsWith('/.ollama/models'))
+        return false;
+    const normalized = relativePath.replaceAll('\\', '/');
+    return normalized.startsWith('blobs/sha256-') || normalized.startsWith('manifests/');
+}
+async function collectFiles(root, directory, depth, options, state) {
+    if (depth > options.maxDepth || state.files.length >= options.maxFiles) {
+        state.limitReached = true;
+        return;
+    }
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(directory, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (state.files.length >= options.maxFiles) {
+            state.limitReached = true;
+            return;
+        }
+        const absolutePath = node_path_1.default.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            await collectFiles(root, absolutePath, depth + 1, options, state);
+            continue;
+        }
+        if (!entry.isFile() && !entry.isSymbolicLink())
+            continue;
+        try {
+            const stat = await promises_1.default.stat(absolutePath);
+            if (!stat.isFile())
+                continue;
+            const relativePath = node_path_1.default.relative(root, absolutePath);
+            const isOllamaStorage = ollamaStorageFile(root, relativePath);
+            const extension = node_path_1.default.extname(entry.name).toLowerCase();
+            if (!isOllamaStorage && !MODEL_EXTENSIONS.has(extension))
+                continue;
+            if (!isOllamaStorage && stat.size < options.minBytes)
+                continue;
+            const fileIdentity = `${stat.dev}:${stat.ino}`;
+            if (state.seenFileIdentities.has(fileIdentity))
+                continue;
+            state.seenFileIdentities.add(fileIdentity);
+            const hfName = huggingFaceName(relativePath);
+            state.files.push({
+                root,
+                relativePath,
+                size: stat.size,
+                modifiedAt: stat.mtime.toISOString(),
+                extension,
+                modelName: isOllamaStorage ? 'ollama-storage' : hfName ?? genericModelName(relativePath),
+                sourceKind: isOllamaStorage ? 'ollama-store' : hfName ? 'huggingface-cache' : 'configured-model-root',
+                fileIdentity,
+                inventoryModel: !isOllamaStorage,
+            });
+        }
+        catch {
+            // A file can disappear between directory enumeration and stat.
+        }
+    }
+}
+function collapseFiles(files) {
+    const groups = new Map();
+    for (const file of files.filter((entry) => entry.inventoryModel)) {
+        const key = `${file.root}:${file.sourceKind}:${file.modelName}`;
+        groups.set(key, [...(groups.get(key) ?? []), file]);
+    }
+    return [...groups.values()].map((group) => {
+        const first = group[0];
+        const evidence = group
+            .map((file) => `${file.relativePath}:${file.size}:${file.modifiedAt}`)
+            .sort()
+            .join('|');
+        const identity = (0, node_crypto_1.createHash)('sha256').update(evidence, 'utf8').digest('hex');
+        const modifiedAt = group.map((file) => file.modifiedAt).sort().at(-1) ?? null;
+        return (0, base_1.createModel)({
+            name: first.modelName,
+            runtime: 'filesystem',
+            identityKind: 'metadata-sha256',
+            identity,
+            source: 'filesystem',
+            confidence: 'low',
+            sizeBytes: group.reduce((total, file) => total + file.size, 0),
+            modifiedAt,
+            locationHint: first.sourceKind,
+        });
+    }).sort((left, right) => left.name.localeCompare(right.name));
+}
+async function scanFilesystemModels(observedAt, input = {}) {
+    const roots = [...new Set((input.roots ?? getDefaultModelRoots()).map((entry) => node_path_1.default.resolve(entry)))];
+    const existingRoots = (await Promise.all(roots.map(async (root) => ({
+        root,
+        exists: await directoryExists(root),
+    })))).filter((entry) => entry.exists).map((entry) => entry.root);
+    const state = { files: [], seenFileIdentities: new Set(), limitReached: false };
+    const options = {
+        minBytes: input.minBytes ?? DEFAULT_MIN_BYTES,
+        maxDepth: input.maxDepth ?? DEFAULT_MAX_DEPTH,
+        maxFiles: input.maxFiles ?? DEFAULT_MAX_FILES,
+    };
+    for (const root of existingRoots) {
+        await collectFiles(root, root, 0, options, state);
+    }
+    const models = collapseFiles(state.files);
+    const logicalBytes = state.files.reduce((total, file) => total + file.size, 0);
+    return {
+        runtime: (0, base_1.createRuntime)({
+            name: 'filesystem',
+            endpoint: null,
+            status: existingRoots.length > 0 ? 'inventory-only' : 'unavailable',
+            modelCount: models.length,
+            observedAt,
+            errorCode: existingRoots.length > 0 ? null : 'no_model_directories_found',
+        }),
+        models,
+        storage: {
+            logical_bytes: logicalBytes,
+            recognized_file_count: state.files.length,
+            complete: !state.limitReached,
+            measurement: 'recognized-logical-file-bytes',
+        },
+        warnings: models.length > 0 ? [
+            {
+                code: 'filesystem_identity_is_metadata_only',
+                message: 'Filesystem identities use names, sizes, and modification times; model bytes were not read.',
+                scope: 'model',
+            },
+            {
+                code: 'filesystem_detection_is_best_effort',
+                message: 'Filesystem findings are best-effort suggestions and may include unrelated weight-like files or miss unsupported locations.',
+                scope: 'model',
+            },
+            ...(state.limitReached ? [{
+                    code: 'filesystem_scan_limit_reached',
+                    message: 'The recognized model-file total is incomplete because the local safety limit was reached.',
+                    scope: 'model',
+                }] : []),
+        ] : [],
+    };
+}
+function filesystemRootFingerprint(root) {
+    return (0, hash_1.stableId)('root', node_path_1.default.resolve(root));
+}
+//# sourceMappingURL=filesystem.js.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/format.d.ts

@@ -0,0 +1,7 @@
+import type { CensusReport } from './types';
+import type { DoctorReport } from './doctor';
+export declare function formatCensusReport(report: CensusReport, options?: {
+    verbose?: boolean;
+}): string;
+export declare function formatDoctorReport(report: DoctorReport): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/format.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCensusReport = formatCensusReport;
+exports.formatDoctorReport = formatDoctorReport;
+function line(label, value) {
+    return `  ${label.padEnd(20)} ${value}`;
+}
+function formatCensusReport(report, options = {}) {
+    const output = [
+        'Forkit AI Footprints',
+        'Metadata-only local AI inventory',
+        '-'.repeat(72),
+        line('census id', report.census_id),
+        line('generated', report.generated_at),
+        line('system', `${report.system.platform}/${report.system.architecture} · Node ${report.system.node_major}`),
+        line('runtimes', `${report.summary.available_runtime_count} available / ${report.summary.runtime_count} observed`),
+        line('models', `${report.summary.model_count} discovered · ${report.summary.confirmed_running_model_count} confirmed running`),
+        line('model storage', `${(report.summary.storage_bytes / (1000 ** 3)).toFixed(2)} GB · ${(report.summary.storage_bytes / (1024 ** 3)).toFixed(2)} GiB · ${report.summary.storage_bytes.toLocaleString('en-US')} recognized logical bytes · ${report.summary.storage_complete ? 'complete supported-root scan' : 'incomplete scan'}`),
+        line('agent products', report.summary.agent_product_count),
+        line('agent processes', report.summary.agent_process_count),
+        line('agent CPU snapshot', report.summary.agent_cpu_percent === null ? 'unavailable' : `${report.summary.agent_cpu_percent.toFixed(1)}%`),
+        line('agent memory snap.', report.summary.agent_memory_percent === null ? 'unavailable' : `${report.summary.agent_memory_percent.toFixed(1)}%`),
+        line('AI tools', report.summary.tool_count),
+        line('MCP configs', report.summary.mcp_config_count),
+        line('warnings', report.summary.warning_count),
+        line('privacy', 'metadata only · no model bytes · no retained commands/config values'),
+    ];
+    if (report.models.length > 0) {
+        output.push('', 'Models');
+        for (const model of report.models) {
+            output.push(`  - ${model.name} · ${model.runtime} · ${model.evidence_status} · ${model.confidence} confidence${options.verbose ? ` · ${model.identity_kind}` : ''}`);
+        }
+    }
+    if (report.runtimes.length > 0) {
+        output.push('', 'Runtimes');
+        for (const runtime of report.runtimes) {
+            output.push(`  - ${runtime.name} · ${runtime.evidence_status} · ${runtime.model_count} model(s)`);
+        }
+    }
+    if (report.agents.length > 0) {
+        output.push('', 'Agent products');
+        for (const agent of report.agents) {
+            output.push(`  - ${agent.name} · ${agent.kind} · ${agent.confidence} confidence · ${agent.instance_count} process(es)`);
+        }
+    }
+    if (report.tools.length > 0) {
+        output.push('', 'AI tools and environments');
+        for (const tool of report.tools) {
+            output.push(`  - ${tool.name} · ${tool.evidence_status} · ${tool.confidence} confidence${options.verbose ? ` · ${tool.detector_types.join('+')}` : ''}`);
+        }
+    }
+    if (report.mcp_configs.length > 0) {
+        output.push('', 'MCP configurations');
+        for (const config of report.mcp_configs) {
+            output.push(`  - ${config.client} · configured · ${config.server_count} server config(s)`);
+        }
+    }
+    if (report.guess.provided !== null) {
+        const difference = report.guess.difference ?? 0;
+        output.push('', `Your guess: ${report.guess.provided} · discovered: ${report.guess.discovered} · difference: ${difference >= 0 ? '+' : ''}${difference}`);
+    }
+    if (report.warnings.length > 0) {
+        output.push('', 'Review notes');
+        for (const warning of report.warnings)
+            output.push(`  - ${warning.message}`);
+    }
+    output.push('', 'Optional next step: use Forkit Connect if you later choose Passport review and an explicit final Mint. AI Footprints has not created or registered anything.');
+    return `${output.join('\n')}\n`;
+}
+function formatDoctorReport(report) {
+    const output = [
+        'Forkit AI Footprints Doctor',
+        '-'.repeat(72),
+        ...report.checks.map((check) => line(check.name, `${check.ok ? 'ok' : 'failed'} · ${check.detail}`)),
+    ];
+    return `${output.join('\n')}\n`;
+}
+//# sourceMappingURL=format.js.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/hash.d.ts

@@ -0,0 +1,4 @@
+export declare function sha256(input: string): string;
+export declare function stableId(prefix: string, input: string): string;
+export declare function normalizeLabel(value: string): string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/hash.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = sha256;
+exports.stableId = stableId;
+exports.normalizeLabel = normalizeLabel;
+const node_crypto_1 = require("node:crypto");
+function sha256(input) {
+    return (0, node_crypto_1.createHash)('sha256').update(input, 'utf8').digest('hex');
+}
+function stableId(prefix, input) {
+    return `${prefix}_${sha256(input).slice(0, 24)}`;
+}
+function normalizeLabel(value) {
+    return String(value || '').trim().replace(/\s+/g, ' ');
+}
+//# sourceMappingURL=hash.js.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/index.d.ts

@@ -0,0 +1,22 @@
+export { detectAgentProducts, listSystemProcesses } from './agents';
+export { aggregateMacosFieldEvaluationDirectory, aggregateMacosFieldEvaluations } from './aggregate';
+export { runCensus } from './census';
+export { authorizeAnonymousAiFootprintContribution, buildAnonymousAiFootprintPreview, MINIMUM_COMPARISON_SECONDS } from './sharing';
+export { ActivityMonitor } from './monitor';
+export type * from './monitor';
+export { buildCensusShareSnapshot, renderCensusSharePage } from './share-page';
+export type { AiFootprintPageOptions } from './share-page';
+export { buildLocalInsights } from './insights';
+export type { LocalInsight, LocalInsightFootprint, LocalInsightKind } from './insights';
+export { startAiFootprintsServer } from './server';
+export type { AiFootprintsServer, AiFootprintsServerOptions } from './server';
+export { detectAiTools } from './tools';
+export { detectMcpConfigs } from './mcp';
+export { runDoctor } from './doctor';
+export { parseLoopbackEndpoint, parseLoopbackEndpointList } from './endpoints';
+export { scanFilesystemModels } from './filesystem';
+export { formatCensusReport, formatDoctorReport } from './format';
+export { detectMacosMajorVersion, evaluateMacosFieldTruth, evaluateMacosFieldTruthFile } from './evaluate';
+export * from './providers';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/index.js

@@ -0,0 +1,58 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateMacosFieldTruthFile = exports.evaluateMacosFieldTruth = exports.detectMacosMajorVersion = exports.formatDoctorReport = exports.formatCensusReport = exports.scanFilesystemModels = exports.parseLoopbackEndpointList = exports.parseLoopbackEndpoint = exports.runDoctor = exports.detectMcpConfigs = exports.detectAiTools = exports.startAiFootprintsServer = exports.buildLocalInsights = exports.renderCensusSharePage = exports.buildCensusShareSnapshot = exports.ActivityMonitor = exports.MINIMUM_COMPARISON_SECONDS = exports.buildAnonymousAiFootprintPreview = exports.authorizeAnonymousAiFootprintContribution = exports.runCensus = exports.aggregateMacosFieldEvaluations = exports.aggregateMacosFieldEvaluationDirectory = exports.listSystemProcesses = exports.detectAgentProducts = void 0;
+var agents_1 = require("./agents");
+Object.defineProperty(exports, "detectAgentProducts", { enumerable: true, get: function () { return agents_1.detectAgentProducts; } });
+Object.defineProperty(exports, "listSystemProcesses", { enumerable: true, get: function () { return agents_1.listSystemProcesses; } });
+var aggregate_1 = require("./aggregate");
+Object.defineProperty(exports, "aggregateMacosFieldEvaluationDirectory", { enumerable: true, get: function () { return aggregate_1.aggregateMacosFieldEvaluationDirectory; } });
+Object.defineProperty(exports, "aggregateMacosFieldEvaluations", { enumerable: true, get: function () { return aggregate_1.aggregateMacosFieldEvaluations; } });
+var census_1 = require("./census");
+Object.defineProperty(exports, "runCensus", { enumerable: true, get: function () { return census_1.runCensus; } });
+var sharing_1 = require("./sharing");
+Object.defineProperty(exports, "authorizeAnonymousAiFootprintContribution", { enumerable: true, get: function () { return sharing_1.authorizeAnonymousAiFootprintContribution; } });
+Object.defineProperty(exports, "buildAnonymousAiFootprintPreview", { enumerable: true, get: function () { return sharing_1.buildAnonymousAiFootprintPreview; } });
+Object.defineProperty(exports, "MINIMUM_COMPARISON_SECONDS", { enumerable: true, get: function () { return sharing_1.MINIMUM_COMPARISON_SECONDS; } });
+var monitor_1 = require("./monitor");
+Object.defineProperty(exports, "ActivityMonitor", { enumerable: true, get: function () { return monitor_1.ActivityMonitor; } });
+var share_page_1 = require("./share-page");
+Object.defineProperty(exports, "buildCensusShareSnapshot", { enumerable: true, get: function () { return share_page_1.buildCensusShareSnapshot; } });
+Object.defineProperty(exports, "renderCensusSharePage", { enumerable: true, get: function () { return share_page_1.renderCensusSharePage; } });
+var insights_1 = require("./insights");
+Object.defineProperty(exports, "buildLocalInsights", { enumerable: true, get: function () { return insights_1.buildLocalInsights; } });
+var server_1 = require("./server");
+Object.defineProperty(exports, "startAiFootprintsServer", { enumerable: true, get: function () { return server_1.startAiFootprintsServer; } });
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "detectAiTools", { enumerable: true, get: function () { return tools_1.detectAiTools; } });
+var mcp_1 = require("./mcp");
+Object.defineProperty(exports, "detectMcpConfigs", { enumerable: true, get: function () { return mcp_1.detectMcpConfigs; } });
+var doctor_1 = require("./doctor");
+Object.defineProperty(exports, "runDoctor", { enumerable: true, get: function () { return doctor_1.runDoctor; } });
+var endpoints_1 = require("./endpoints");
+Object.defineProperty(exports, "parseLoopbackEndpoint", { enumerable: true, get: function () { return endpoints_1.parseLoopbackEndpoint; } });
+Object.defineProperty(exports, "parseLoopbackEndpointList", { enumerable: true, get: function () { return endpoints_1.parseLoopbackEndpointList; } });
+var filesystem_1 = require("./filesystem");
+Object.defineProperty(exports, "scanFilesystemModels", { enumerable: true, get: function () { return filesystem_1.scanFilesystemModels; } });
+var format_1 = require("./format");
+Object.defineProperty(exports, "formatCensusReport", { enumerable: true, get: function () { return format_1.formatCensusReport; } });
+Object.defineProperty(exports, "formatDoctorReport", { enumerable: true, get: function () { return format_1.formatDoctorReport; } });
+var evaluate_1 = require("./evaluate");
+Object.defineProperty(exports, "detectMacosMajorVersion", { enumerable: true, get: function () { return evaluate_1.detectMacosMajorVersion; } });
+Object.defineProperty(exports, "evaluateMacosFieldTruth", { enumerable: true, get: function () { return evaluate_1.evaluateMacosFieldTruth; } });
+Object.defineProperty(exports, "evaluateMacosFieldTruthFile", { enumerable: true, get: function () { return evaluate_1.evaluateMacosFieldTruthFile; } });
+__exportStar(require("./providers"), exports);
+//# sourceMappingURL=index.js.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/insights.d.ts

@@ -0,0 +1,13 @@
+import type { MonitorSnapshot } from './monitor';
+import { type UiLocale } from './localization';
+export type LocalInsightKind = 'activity-share' | 'longest-block' | 'workflow' | 'local-models-unused' | 'mostly-idle';
+export interface LocalInsight {
+    kind: LocalInsightKind;
+    text: string;
+}
+export interface LocalInsightFootprint {
+    model_record_count: number;
+    confirmed_running_model_count: number;
+}
+export declare function buildLocalInsights(monitor: MonitorSnapshot, footprint: LocalInsightFootprint, minimumSeconds?: number, locale?: UiLocale): LocalInsight[];
+//# sourceMappingURL=insights.d.ts.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/insights.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLocalInsights = buildLocalInsights;
+const localization_1 = require("./localization");
+const MINIMUM_INSIGHT_SECONDS = 60;
+function durationLabel(value, locale) {
+    const seconds = Math.max(0, Math.round(value));
+    if (seconds < 60)
+        return locale === 'de' ? `${seconds} Sek` : `${seconds}s`;
+    if (seconds < 3600)
+        return locale === 'de' ? `${Math.floor(seconds / 60)} Min ${seconds % 60} Sek` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+    return locale === 'de' ? `${Math.floor(seconds / 3600)} Std ${Math.floor((seconds % 3600) / 60)} Min` : `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
+}
+function longestActiveSeconds(timeline, gapToleranceMs) {
+    let longest = 0;
+    let blockStart = null;
+    let blockEnd = null;
+    let observationId;
+    for (const segment of timeline) {
+        if (segment.state !== 'working-now') {
+            if (blockStart !== null && blockEnd !== null)
+                longest = Math.max(longest, blockEnd - blockStart);
+            blockStart = null;
+            blockEnd = null;
+            observationId = undefined;
+            continue;
+        }
+        const started = Date.parse(segment.started_at);
+        const ended = Date.parse(segment.ended_at);
+        if (!Number.isFinite(started) || !Number.isFinite(ended) || ended < started)
+            continue;
+        const sessionChanged = observationId !== undefined && segment.observation_id !== undefined && segment.observation_id !== observationId;
+        if (blockStart === null || blockEnd === null || sessionChanged || started - blockEnd > gapToleranceMs) {
+            if (blockStart !== null && blockEnd !== null)
+                longest = Math.max(longest, blockEnd - blockStart);
+            blockStart = started;
+            blockEnd = ended;
+            observationId = segment.observation_id;
+        }
+        else
+            blockEnd = Math.max(blockEnd, ended);
+    }
+    if (blockStart !== null && blockEnd !== null)
+        longest = Math.max(longest, blockEnd - blockStart);
+    return longest / 1000;
+}
+function buildLocalInsights(monitor, footprint, minimumSeconds = MINIMUM_INSIGHT_SECONDS, locale = 'en') {
+    if (monitor.observed_seconds < minimumSeconds || monitor.activity_ratio === null)
+        return [];
+    const insights = [];
+    const activeProducts = monitor.products.filter((product) => product.active_seconds > 0);
+    const activityPercent = Math.round(monitor.activity_ratio * 100);
+    if (monitor.activity_ratio <= 0.2) {
+        insights.push({ kind: 'mostly-idle', text: (0, localization_1.uiText)(locale, 'insightMostlyIdle') });
+    }
+    else if (activeProducts.length === 1) {
+        insights.push({ kind: 'activity-share', text: (0, localization_1.uiText)(locale, 'insightActivityProduct', { product: activeProducts[0].name, percent: activityPercent }) });
+    }
+    else {
+        insights.push({ kind: 'activity-share', text: (0, localization_1.uiText)(locale, 'insightActivityGeneric', { percent: activityPercent }) });
+    }
+    const longest = longestActiveSeconds(monitor.timeline, monitor.sample_interval_ms * 3);
+    if (longest >= 10)
+        insights.push({ kind: 'longest-block', text: (0, localization_1.uiText)(locale, 'insightLongest', { duration: durationLabel(longest, locale) }) });
+    if (activeProducts.length > 1) {
+        insights.push({ kind: 'workflow', text: (0, localization_1.uiText)(locale, 'insightMulti', { count: activeProducts.length }) });
+    }
+    else if (footprint.model_record_count > 0 && footprint.confirmed_running_model_count === 0) {
+        insights.push({ kind: 'local-models-unused', text: (0, localization_1.uiText)(locale, 'insightModelsUnused', { count: footprint.model_record_count }) });
+    }
+    else if (activeProducts.length === 1 && insights[0]?.kind !== 'activity-share') {
+        insights.push({ kind: 'workflow', text: (0, localization_1.uiText)(locale, 'insightFocused', { product: activeProducts[0].name }) });
+    }
+    return insights.slice(0, 3);
+}
+//# sourceMappingURL=insights.js.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/local-device.d.ts

@@ -0,0 +1,19 @@
+export interface LocalDeviceJournal {
+    schema_version: '1.0';
+    device_label: string;
+    device_label_source: 'macos-computer-name' | 'local-hostname' | 'generic-mac';
+    first_scan_at: string;
+    last_scan_at: string;
+    scan_count: number;
+}
+interface RecordLocalScanOptions {
+    stateDirectory?: string;
+    deviceLabel?: string;
+    now?: () => Date;
+    platform?: NodeJS.Platform;
+}
+export declare function defaultLocalStateDirectory(): string;
+export declare function detectLocalDeviceLabel(platform?: NodeJS.Platform): Pick<LocalDeviceJournal, 'device_label' | 'device_label_source'>;
+export declare function recordLocalScan(options?: RecordLocalScanOptions): Promise<LocalDeviceJournal>;
+export {};
+//# sourceMappingURL=local-device.d.ts.map