@automaton-labs/aib 0.0.7 → 0.0.8

package/dist/mutation/targeted-import-canonicalizer.js

@@ -0,0 +1,359 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chooseTargetedImportSpecifier = chooseTargetedImportSpecifier;
+exports.canonicalizeTargetedNamedImports = canonicalizeTargetedNamedImports;
+exports.formatChangedNamedImports = formatChangedNamedImports;
+exports.renderTargetedNamedImportLike = renderTargetedNamedImportLike;
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const import_rules_1 = require("../config/import-rules");
+const import_specifier_policy_1 = require("../commands/import-specifier-policy");
+function chooseTargetedImportSpecifier(input) {
+    const config = (0, import_specifier_policy_1.readNearestTsConfig)(input.fromFile, input.cwd, input.tsConfigCache);
+    const rule = (0, import_rules_1.resolveImportRuleForFile)(input.fromFile, input.importRules) ?? {
+        scope: ".",
+        scopePath: input.cwd,
+        specifier: "relative",
+        ending: "js"
+    };
+    return (0, import_specifier_policy_1.chooseImportSpecifier)({
+        fromFile: input.fromFile,
+        targetFile: input.targetFile,
+        config,
+        rule,
+        allowIndexCollapse: input.allowIndexCollapse
+    });
+}
+function canonicalizeTargetedNamedImports(text, file, options = {}) {
+    const parsed = createSourceFile(file, text);
+    const groups = new Map();
+    for (const statement of parsed.statements) {
+        if (!typescript_1.default.isImportDeclaration(statement) || !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier)) {
+            continue;
+        }
+        const importClause = statement.importClause;
+        const namedBindings = importClause?.namedBindings;
+        if (!importClause || namedBindings && typescript_1.default.isNamespaceImport(namedBindings)) {
+            continue;
+        }
+        const key = `${statement.moduleSpecifier.text}\0${readAttributesText(statement, parsed)}`;
+        groups.set(key, [...(groups.get(key) ?? []), statement]);
+    }
+    const replacements = [];
+    let mergedGroups = 0;
+    for (const declarations of groups.values()) {
+        const specifier = declarations[0]?.moduleSpecifier;
+        if (options.moduleSpecifiers && (!specifier || !typescript_1.default.isStringLiteralLike(specifier) || !options.moduleSpecifiers.has(specifier.text))) {
+            continue;
+        }
+        if (declarations.length < 2 || hasAmbiguousComments(text, parsed, declarations)) {
+            continue;
+        }
+        const replacementText = renderCanonicalImportGroup(text, parsed, declarations);
+        if (replacementText === null) {
+            continue;
+        }
+        mergedGroups += 1;
+        const first = declarations[0];
+        replacements.push({ start: first.getStart(parsed), end: first.end, text: replacementText });
+        for (const duplicate of declarations.slice(1)) {
+            replacements.push({
+                start: duplicate.getStart(parsed),
+                end: readStatementEndWithTrailingNewline(text, duplicate.end),
+                text: ""
+            });
+        }
+    }
+    let next = text;
+    for (const replacement of replacements.sort((left, right) => right.start - left.start)) {
+        next = `${next.slice(0, replacement.start)}${replacement.text}${next.slice(replacement.end)}`;
+    }
+    return { text: next, changed: next !== text, mergedGroups };
+}
+function formatChangedNamedImports(beforeText, text, file) {
+    const moduleSpecifiers = changedImportSpecifiers(beforeText, text, file);
+    if (moduleSpecifiers.size === 0) {
+        return { text, changed: false, mergedGroups: 0 };
+    }
+    const canonicalized = canonicalizeTargetedNamedImports(text, file, { moduleSpecifiers });
+    const source = createSourceFile(file, canonicalized.text);
+    const replacements = [];
+    for (const statement of source.statements) {
+        if (!typescript_1.default.isImportDeclaration(statement) || !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier) ||
+            !moduleSpecifiers.has(statement.moduleSpecifier.text)) {
+            continue;
+        }
+        const clause = statement.importClause;
+        const bindings = clause?.namedBindings;
+        if (!clause || !bindings || !typescript_1.default.isNamedImports(bindings) || hasImportClauseComments(canonicalized.text, source, statement)) {
+            continue;
+        }
+        const rendered = renderTargetedNamedImportLike({
+            sourceText: canonicalized.text,
+            sourceFile: source,
+            statement,
+            elements: bindings.elements.map((element) => ({
+                text: element.getText(source).replace(/^type\s+/, ""),
+                isTypeOnly: clause.isTypeOnly || element.isTypeOnly
+            })),
+            specifier: statement.moduleSpecifier.text,
+            clauseTypeOnly: clause.isTypeOnly
+        });
+        if (rendered !== canonicalized.text.slice(statement.getStart(source), statement.getEnd())) {
+            replacements.push({ start: statement.getStart(source), end: statement.getEnd(), text: rendered });
+        }
+    }
+    let next = canonicalized.text;
+    for (const replacement of replacements.sort((left, right) => right.start - left.start)) {
+        next = `${next.slice(0, replacement.start)}${replacement.text}${next.slice(replacement.end)}`;
+    }
+    next = collapseExtraSpacingAfterChangedImports(next, file, moduleSpecifiers);
+    return {
+        text: next,
+        changed: next !== text,
+        mergedGroups: canonicalized.mergedGroups
+    };
+}
+function collapseExtraSpacingAfterChangedImports(text, file, moduleSpecifiers) {
+    const source = createSourceFile(file, text);
+    const replacements = [];
+    for (let index = 0; index < source.statements.length - 1; index += 1) {
+        const statement = source.statements[index];
+        const nextStatement = source.statements[index + 1];
+        if (!typescript_1.default.isImportDeclaration(statement) || !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier) ||
+            !moduleSpecifiers.has(statement.moduleSpecifier.text)) {
+            continue;
+        }
+        const start = statement.getEnd();
+        const end = nextStatement.getStart(source);
+        const gap = text.slice(start, end);
+        if (!/^(?:[ \t]*\r?\n){3,}[ \t]*$/.test(gap))
+            continue;
+        const newline = gap.includes("\r\n") ? "\r\n" : "\n";
+        replacements.push({ start, end, text: `${newline}${newline}` });
+    }
+    let output = text;
+    for (const replacement of replacements.sort((left, right) => right.start - left.start)) {
+        output = `${output.slice(0, replacement.start)}${replacement.text}${output.slice(replacement.end)}`;
+    }
+    return output;
+}
+function renderTargetedNamedImportLike(input) {
+    const style = readImportStyle(input.sourceText, input.sourceFile, [input.statement]);
+    const allTypeOnly = input.clauseTypeOnly || input.elements.every((element) => element.isTypeOnly);
+    const elements = orderNamedElements(input.elements).map((element) => allTypeOnly || !element.isTypeOnly ? element.text.replace(/^type\s+/, "") : `type ${element.text.replace(/^type\s+/, "")}`);
+    const namedClause = renderNamedClause(elements, style);
+    const defaultBinding = input.defaultBinding === undefined
+        ? input.statement.importClause?.name?.getText(input.sourceFile) ?? null
+        : input.defaultBinding;
+    const bindings = [defaultBinding, namedClause].filter((item) => Boolean(item)).join(", ");
+    const attributes = readAttributesText(input.statement, input.sourceFile);
+    const attributesSuffix = attributes ? ` ${attributes}` : "";
+    const quote = style.moduleText.startsWith("'") ? "'" : "\"";
+    return `${style.indent}import ${allTypeOnly ? "type " : ""}${bindings} from ${quote}${input.specifier}${quote}${attributesSuffix}${style.semicolon}`;
+}
+function renderCanonicalImportGroup(sourceText, sourceFile, declarations) {
+    const first = declarations[0];
+    if (!first || !typescript_1.default.isStringLiteralLike(first.moduleSpecifier)) {
+        return null;
+    }
+    const attributes = readAttributesText(first, sourceFile);
+    let defaultBinding = null;
+    const named = new Map();
+    for (const declaration of declarations) {
+        const clause = declaration.importClause;
+        if (!clause || readAttributesText(declaration, sourceFile) !== attributes) {
+            return null;
+        }
+        if (clause.name) {
+            const name = clause.name.getText(sourceFile);
+            if (defaultBinding && defaultBinding.text !== name) {
+                return null;
+            }
+            const previous = defaultBinding;
+            defaultBinding = { text: name, isTypeOnly: (previous?.isTypeOnly ?? true) && clause.isTypeOnly };
+        }
+        const bindings = clause.namedBindings;
+        if (!bindings) {
+            continue;
+        }
+        if (!typescript_1.default.isNamedImports(bindings)) {
+            return null;
+        }
+        for (const element of bindings.elements) {
+            const bindingText = element.getText(sourceFile).replace(/^type\s+/, "");
+            const current = named.get(bindingText);
+            named.set(bindingText, {
+                text: bindingText,
+                isTypeOnly: (current?.isTypeOnly ?? true) && (clause.isTypeOnly || element.isTypeOnly)
+            });
+        }
+    }
+    const hasValueNamed = Array.from(named.values()).some((element) => !element.isTypeOnly);
+    if (defaultBinding?.isTypeOnly && named.size > 0) {
+        return null;
+    }
+    const allTypeOnly = Boolean(defaultBinding?.isTypeOnly || !defaultBinding) && !hasValueNamed;
+    const style = readImportStyle(sourceText, sourceFile, declarations);
+    const namedElements = orderNamedElements(Array.from(named.values())).map((element) => allTypeOnly || !element.isTypeOnly ? element.text : `type ${element.text}`);
+    const namedClause = namedElements.length > 0 ? renderNamedClause(namedElements, style) : null;
+    const clauses = [defaultBinding?.text ?? null, namedClause].filter((item) => Boolean(item));
+    if (clauses.length === 0) {
+        return null;
+    }
+    const attributesSuffix = attributes ? ` ${attributes}` : "";
+    return `${style.indent}import ${allTypeOnly ? "type " : ""}${clauses.join(", ")} from ${style.moduleText}${attributesSuffix}${style.semicolon}`;
+}
+function readImportStyle(sourceText, sourceFile, declarations) {
+    const first = declarations[0];
+    const bindings = declarations.flatMap((declaration) => {
+        const namedBindings = declaration.importClause?.namedBindings;
+        return namedBindings && typescript_1.default.isNamedImports(namedBindings) ? [namedBindings] : [];
+    });
+    const multilineBindings = bindings.find((namedBindings) => /\r?\n/.test(namedBindings.getText(sourceFile)));
+    const firstElement = multilineBindings?.elements[0];
+    const indent = sourceText.slice(readLineStart(sourceText, first.getStart(sourceFile)), first.getStart(sourceFile));
+    return {
+        indent,
+        elementIndent: firstElement
+            ? sourceText.slice(readLineStart(sourceText, firstElement.getStart(sourceFile)), firstElement.getStart(sourceFile))
+            : `${indent}  `,
+        moduleText: sourceText.slice(first.moduleSpecifier.getStart(sourceFile), first.moduleSpecifier.getEnd()),
+        semicolon: first.getText(sourceFile).trimEnd().endsWith(";") ? ";" : "",
+        newline: sourceText.includes("\r\n") ? "\r\n" : "\n"
+    };
+}
+function renderNamedClause(elements, style) {
+    if (elements.length <= 1) {
+        return `{ ${elements.join("")} }`;
+    }
+    const body = elements.map((element) => `${style.elementIndent}${element},`).join(style.newline);
+    return `{${style.newline}${body}${style.newline}${style.indent}}`;
+}
+function orderNamedElements(elements) {
+    return [...elements].sort((left, right) => {
+        if (left.isTypeOnly !== right.isTypeOnly)
+            return left.isTypeOnly ? 1 : -1;
+        return left.text < right.text ? -1 : left.text > right.text ? 1 : 0;
+    });
+}
+function changedImportSpecifiers(beforeText, text, file) {
+    const before = importGroupSignatures(beforeText, file);
+    const after = importGroupSignatures(text, file);
+    const changed = new Set();
+    for (const [specifier, signatures] of after) {
+        if (JSON.stringify(signatures) !== JSON.stringify(before.get(specifier) ?? [])) {
+            changed.add(specifier);
+        }
+    }
+    return changed;
+}
+function importGroupSignatures(text, file) {
+    const source = createSourceFile(file, text);
+    const groups = new Map();
+    for (const statement of source.statements) {
+        if (!typescript_1.default.isImportDeclaration(statement) || !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier))
+            continue;
+        const clause = statement.importClause;
+        const bindings = clause?.namedBindings;
+        const named = bindings && typescript_1.default.isNamedImports(bindings)
+            ? bindings.elements.map((element) => [
+                element.propertyName?.text ?? "",
+                element.name.text,
+                clause?.isTypeOnly === true || element.isTypeOnly
+            ])
+            : [];
+        const signature = JSON.stringify({
+            attributes: readAttributesText(statement, source),
+            typeOnly: clause?.isTypeOnly === true,
+            defaultName: clause?.name?.text ?? null,
+            namespaceName: bindings && typescript_1.default.isNamespaceImport(bindings) ? bindings.name.text : null,
+            named
+        });
+        groups.set(statement.moduleSpecifier.text, [...(groups.get(statement.moduleSpecifier.text) ?? []), signature].sort());
+    }
+    return groups;
+}
+function hasImportClauseComments(text, source, statement) {
+    const clause = statement.importClause;
+    return clause ? /\/\*|\/\//.test(text.slice(clause.getStart(source), clause.getEnd())) : false;
+}
+function readAttributesText(statement, sourceFile) {
+    return statement.attributes?.getText(sourceFile) ?? "";
+}
+function hasAmbiguousComments(sourceText, sourceFile, declarations) {
+    return declarations.some((declaration, index) => {
+        if (/\/\/|\/\*/.test(declaration.getText(sourceFile))) {
+            return true;
+        }
+        const lineStart = readLineStart(sourceText, declaration.getStart(sourceFile));
+        if (sourceText.slice(lineStart, declaration.getStart(sourceFile)).trim().length > 0) {
+            return true;
+        }
+        const lineEnd = sourceText.indexOf("\n", declaration.end);
+        if (/\/\/|\/\*/.test(sourceText.slice(declaration.end, lineEnd < 0 ? sourceText.length : lineEnd))) {
+            return true;
+        }
+        return index > 0 && /\/\/|\/\*/.test(sourceText.slice(declaration.getFullStart(), declaration.getStart(sourceFile)));
+    });
+}
+function readLineStart(text, offset) {
+    const previous = text.lastIndexOf("\n", Math.max(0, offset - 1));
+    return previous < 0 ? 0 : previous + 1;
+}
+function createSourceFile(file, text) {
+    const extension = path.extname(file).toLowerCase();
+    const scriptKind = extension === ".tsx"
+        ? typescript_1.default.ScriptKind.TSX
+        : extension === ".jsx"
+            ? typescript_1.default.ScriptKind.JSX
+            : extension === ".js" || extension === ".mjs" || extension === ".cjs"
+                ? typescript_1.default.ScriptKind.JS
+                : typescript_1.default.ScriptKind.TS;
+    return typescript_1.default.createSourceFile(file, text, typescript_1.default.ScriptTarget.Latest, true, scriptKind);
+}
+function readStatementEndWithTrailingNewline(text, end) {
+    if (text[end] === "\r" && text[end + 1] === "\n") {
+        return end + 2;
+    }
+    if (text[end] === "\n") {
+        return end + 1;
+    }
+    return end;
+}

package/dist/observability/config.js

@@ -1 +1,206 @@
-"use strict";var b=exports&&exports.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.DEFAULT_OBSERVABILITY_CONFIG=void 0,exports.resolveObservabilityConfig=l,exports.traceEnabled=h,exports.failureSnapshotsEnabled=g,exports.defaultTraceWorkspaceDir=S,exports.feedbackFilePath=_,exports.failureSnapshotsRoot=k,exports.observabilityStatus=E;const c=b(require("node:fs")),n=b(require("node:path")),s=require("../config/env-vars"),u=require("../config/product-storage"),y=require("./context");exports.DEFAULT_OBSERVABILITY_CONFIG={metrics:"on",mutationImpactMetrics:"on",trace:"full",failureSnapshots:"on",feedback:"on",retention:{metrics:{maxAgeDays:30,maxTotalMb:512,maxPerWorkspaceMb:128},trace:{maxAgeDays:14,maxTotalMb:512,maxPerWorkspaceMb:128},failureSnapshots:{maxAgeDays:14,maxTotalMb:512,maxPerWorkspaceMb:128,maxFileMb:2,maxFilesPerFailure:5},feedback:{cleanup:"dangerOnly"}}};function l(){const e=JSON.parse(JSON.stringify(exports.DEFAULT_OBSERVABILITY_CONFIG)),t=d(process.env[s.CLI_ENV.metrics]);t&&(e.metrics=t);const r=d(process.env[s.CLI_ENV.mutationImpactMetrics]);r&&(e.mutationImpactMetrics=r);const o=R(process.env[s.CLI_ENV.trace]);o&&(e.trace=o);const a=d(process.env[s.CLI_ENV.failureSnapshots]);return a&&(e.failureSnapshots=a),e}function h(){return l().trace!=="off"}function g(){return l().failureSnapshots==="on"&&h()}function S(e){const t=(0,y.resolveWorkspaceIdentity)(e);return n.default.join((0,u.productStorageRoot)(),"trace","workspaces",t.workspaceId)}function _(){return n.default.join((0,u.productStorageRoot)(),"feedback","feedback.jsonl")}function k(e){const t=(0,y.resolveWorkspaceIdentity)(e);return n.default.join((0,u.productStorageRoot)(),"failure-snapshots","workspaces",t.workspaceId)}function E(e){const t=l(),r=(0,u.productStorageRoot)(),o=S(e),a=_(),i=process.env[s.CLI_ENV.metricsDir]?.trim()?n.default.resolve(process.env[s.CLI_ENV.metricsDir]):n.default.join(r,"metrics"),f=k(e);return{ok:!0,command:"observability",action:"status",productStorageRoot:r,config:t,effective:{metrics:t.metrics,mutationImpactMetrics:t.mutationImpactMetrics,trace:t.trace,failureSnapshots:t.failureSnapshots,feedback:t.feedback},storage:{metricsDir:i,metricsFile:n.default.join(i,"metrics.jsonl"),traceDir:o,feedbackFile:a,failureSnapshotsRoot:f},counters:{metricsRows:v(n.default.join(i,"metrics.jsonl")),metricsBytes:p(n.default.join(i,"metrics.jsonl")),traceBytes:m(n.default.dirname(n.default.dirname(o))),feedbackRows:v(a),feedbackBytes:p(a),failureSnapshotBytes:m(f),failureSnapshotCount:I(f)},cleanup:{enforced:!1,dryRunAvailable:!0,note:"Retention config is visible but automatic cleanup is not enforced yet."}}}function d(e){if(e===void 0)return null;const t=e.trim().toLowerCase();return["0","false","off","disabled","no"].includes(t)?"off":["1","true","on","enabled","yes"].includes(t)?"on":null}function R(e){if(e===void 0)return null;const t=e.trim().toLowerCase();return["0","false","off","disabled","no"].includes(t)?"off":t==="light"?"light":["1","true","on","enabled","yes","full"].includes(t)?"full":null}function p(e){try{return c.default.statSync(e).size}catch{return 0}}function v(e){try{return c.default.readFileSync(e,"utf8").split(/\r?\n/).filter(Boolean).length}catch{return 0}}function m(e){let t=0;try{for(const r of c.default.readdirSync(e,{withFileTypes:!0})){const o=n.default.join(e,r.name);r.isDirectory()?t+=m(o):r.isFile()&&(t+=p(o))}}catch{return 0}return t}function I(e){let t=0;try{for(const r of c.default.readdirSync(e,{withFileTypes:!0}))r.isDirectory()&&(t+=1+I(n.default.join(e,r.name)))}catch{return 0}return t}
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_OBSERVABILITY_CONFIG = void 0;
+exports.resolveObservabilityConfig = resolveObservabilityConfig;
+exports.traceEnabled = traceEnabled;
+exports.failureSnapshotsEnabled = failureSnapshotsEnabled;
+exports.defaultTraceWorkspaceDir = defaultTraceWorkspaceDir;
+exports.feedbackFilePath = feedbackFilePath;
+exports.failureSnapshotsRoot = failureSnapshotsRoot;
+exports.observabilityStatus = observabilityStatus;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const env_vars_1 = require("../config/env-vars");
+const product_storage_1 = require("../config/product-storage");
+const context_1 = require("./context");
+exports.DEFAULT_OBSERVABILITY_CONFIG = {
+    metrics: "on",
+    mutationImpactMetrics: "on",
+    trace: "full",
+    failureSnapshots: "on",
+    feedback: "on",
+    retention: {
+        metrics: {
+            maxAgeDays: 30,
+            maxTotalMb: 512,
+            maxPerWorkspaceMb: 128
+        },
+        trace: {
+            maxAgeDays: 14,
+            maxTotalMb: 512,
+            maxPerWorkspaceMb: 128
+        },
+        failureSnapshots: {
+            maxAgeDays: 14,
+            maxTotalMb: 512,
+            maxPerWorkspaceMb: 128,
+            maxFileMb: 2,
+            maxFilesPerFailure: 5
+        },
+        feedback: {
+            cleanup: "dangerOnly"
+        }
+    }
+};
+function resolveObservabilityConfig() {
+    const config = JSON.parse(JSON.stringify(exports.DEFAULT_OBSERVABILITY_CONFIG));
+    const metrics = readToggleEnv(process.env[env_vars_1.CLI_ENV.metrics]);
+    if (metrics) {
+        config.metrics = metrics;
+    }
+    const impact = readToggleEnv(process.env[env_vars_1.CLI_ENV.mutationImpactMetrics]);
+    if (impact) {
+        config.mutationImpactMetrics = impact;
+    }
+    const trace = readTraceEnv(process.env[env_vars_1.CLI_ENV.trace]);
+    if (trace) {
+        config.trace = trace;
+    }
+    const snapshots = readToggleEnv(process.env[env_vars_1.CLI_ENV.failureSnapshots]);
+    if (snapshots) {
+        config.failureSnapshots = snapshots;
+    }
+    return config;
+}
+function traceEnabled() {
+    return resolveObservabilityConfig().trace !== "off";
+}
+function failureSnapshotsEnabled() {
+    return resolveObservabilityConfig().failureSnapshots === "on" && traceEnabled();
+}
+function defaultTraceWorkspaceDir(cwd) {
+    const workspace = (0, context_1.resolveWorkspaceIdentity)(cwd);
+    return node_path_1.default.join((0, product_storage_1.productStorageRoot)(), "trace", "workspaces", workspace.workspaceId);
+}
+function feedbackFilePath() {
+    return node_path_1.default.join((0, product_storage_1.productStorageRoot)(), "feedback", "feedback.jsonl");
+}
+function failureSnapshotsRoot(cwd) {
+    const workspace = (0, context_1.resolveWorkspaceIdentity)(cwd);
+    return node_path_1.default.join((0, product_storage_1.productStorageRoot)(), "failure-snapshots", "workspaces", workspace.workspaceId);
+}
+function observabilityStatus(cwd) {
+    const config = resolveObservabilityConfig();
+    const productRoot = (0, product_storage_1.productStorageRoot)();
+    const traceDir = defaultTraceWorkspaceDir(cwd);
+    const feedbackFile = feedbackFilePath();
+    const metricsDir = process.env[env_vars_1.CLI_ENV.metricsDir]?.trim()
+        ? node_path_1.default.resolve(process.env[env_vars_1.CLI_ENV.metricsDir])
+        : node_path_1.default.join(productRoot, "metrics");
+    const snapshotRoot = failureSnapshotsRoot(cwd);
+    return {
+        ok: true,
+        command: "observability",
+        action: "status",
+        productStorageRoot: productRoot,
+        config,
+        effective: {
+            metrics: config.metrics,
+            mutationImpactMetrics: config.mutationImpactMetrics,
+            trace: config.trace,
+            failureSnapshots: config.failureSnapshots,
+            feedback: config.feedback
+        },
+        storage: {
+            metricsDir,
+            metricsFile: node_path_1.default.join(metricsDir, "metrics.jsonl"),
+            traceDir,
+            feedbackFile,
+            failureSnapshotsRoot: snapshotRoot
+        },
+        counters: {
+            metricsRows: countJsonlRows(node_path_1.default.join(metricsDir, "metrics.jsonl")),
+            metricsBytes: fileSize(node_path_1.default.join(metricsDir, "metrics.jsonl")),
+            traceBytes: dirSize(node_path_1.default.dirname(node_path_1.default.dirname(traceDir))),
+            feedbackRows: countJsonlRows(feedbackFile),
+            feedbackBytes: fileSize(feedbackFile),
+            failureSnapshotBytes: dirSize(snapshotRoot),
+            failureSnapshotCount: countDirectories(snapshotRoot)
+        },
+        cleanup: {
+            enforced: false,
+            dryRunAvailable: true,
+            note: "Retention config is visible but automatic cleanup is not enforced yet."
+        }
+    };
+}
+function readToggleEnv(value) {
+    if (value === undefined) {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["0", "false", "off", "disabled", "no"].includes(normalized)) {
+        return "off";
+    }
+    if (["1", "true", "on", "enabled", "yes"].includes(normalized)) {
+        return "on";
+    }
+    return null;
+}
+function readTraceEnv(value) {
+    if (value === undefined) {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["0", "false", "off", "disabled", "no"].includes(normalized)) {
+        return "off";
+    }
+    if (normalized === "light") {
+        return "light";
+    }
+    if (["1", "true", "on", "enabled", "yes", "full"].includes(normalized)) {
+        return "full";
+    }
+    return null;
+}
+function fileSize(file) {
+    try {
+        return node_fs_1.default.statSync(file).size;
+    }
+    catch {
+        return 0;
+    }
+}
+function countJsonlRows(file) {
+    try {
+        return node_fs_1.default.readFileSync(file, "utf8").split(/\r?\n/).filter(Boolean).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function dirSize(dir) {
+    let total = 0;
+    try {
+        for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = node_path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                total += dirSize(fullPath);
+            }
+            else if (entry.isFile()) {
+                total += fileSize(fullPath);
+            }
+        }
+    }
+    catch {
+        return 0;
+    }
+    return total;
+}
+function countDirectories(dir) {
+    let count = 0;
+    try {
+        for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                count += 1 + countDirectories(node_path_1.default.join(dir, entry.name));
+            }
+        }
+    }
+    catch {
+        return 0;
+    }
+    return count;
+}

package/dist/observability/context.js

@@ -1 +1,59 @@
-"use strict";var i=exports&&exports.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.resolveWorkspaceIdentity=a,exports.resolveSessionIdentity=c,exports.buildCorrelationContext=d;const r=i(require("node:path")),u=require("node:crypto"),n=require("../config/env-vars"),l=require("../config/workspace-root"),p=require("../commands/session-workspace"),_=require("../shared/errors");function a(e){const o=k(e),s=r.default.resolve(o),t=(0,u.createHash)("sha1").update(s.toLowerCase()).digest("hex").slice(0,12);return{workspaceId:`${r.default.basename(s).replace(/[^A-Za-z0-9._-]/g,"-")||"workspace"}-${t}`,workspacePathHash:t,workspaceRoot:s}}function c(e){try{return(0,p.tryResolveCurrentSessionId)(e)}catch{const o=process.env[n.CLI_ENV.session]?.trim()||process.env[n.CLI_ENV.legacySession]?.trim();return{sessionId:o||null,sessionSource:o?"env":"none"}}}function d(e){const o=a(e),s=c(e);return{workspaceId:o.workspaceId,workspacePathHash:o.workspacePathHash,workspaceRoot:o.workspaceRoot,...s.sessionId?{sessionId:s.sessionId}:{},sessionSource:s.sessionSource}}function k(e){try{return(0,l.resolveWorkspaceRoot)(e)?.root??r.default.resolve(e)}catch(o){if(o instanceof _.CliError&&o.code==="AIB_CONFIG_INVALID")return r.default.resolve(e);throw o}}
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWorkspaceIdentity = resolveWorkspaceIdentity;
+exports.resolveSessionIdentity = resolveSessionIdentity;
+exports.buildCorrelationContext = buildCorrelationContext;
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const env_vars_1 = require("../config/env-vars");
+const workspace_root_1 = require("../config/workspace-root");
+const session_workspace_1 = require("../commands/session-workspace");
+const errors_1 = require("../shared/errors");
+function resolveWorkspaceIdentity(cwd) {
+    const workspaceRoot = resolveSafeWorkspaceRoot(cwd);
+    const normalized = node_path_1.default.resolve(workspaceRoot);
+    const workspacePathHash = (0, node_crypto_1.createHash)("sha1").update(normalized.toLowerCase()).digest("hex").slice(0, 12);
+    const name = node_path_1.default.basename(normalized).replace(/[^A-Za-z0-9._-]/g, "-") || "workspace";
+    return {
+        workspaceId: `${name}-${workspacePathHash}`,
+        workspacePathHash,
+        workspaceRoot: normalized
+    };
+}
+function resolveSessionIdentity(cwd) {
+    try {
+        return (0, session_workspace_1.tryResolveCurrentSessionId)(cwd);
+    }
+    catch {
+        const envSession = process.env[env_vars_1.CLI_ENV.session]?.trim() || process.env[env_vars_1.CLI_ENV.legacySession]?.trim();
+        return {
+            sessionId: envSession || null,
+            sessionSource: envSession ? "env" : "none"
+        };
+    }
+}
+function buildCorrelationContext(cwd) {
+    const workspace = resolveWorkspaceIdentity(cwd);
+    const session = resolveSessionIdentity(cwd);
+    return {
+        workspaceId: workspace.workspaceId,
+        workspacePathHash: workspace.workspacePathHash,
+        workspaceRoot: workspace.workspaceRoot,
+        ...(session.sessionId ? { sessionId: session.sessionId } : {}),
+        sessionSource: session.sessionSource
+    };
+}
+function resolveSafeWorkspaceRoot(cwd) {
+    try {
+        return (0, workspace_root_1.resolveWorkspaceRoot)(cwd)?.root ?? node_path_1.default.resolve(cwd);
+    }
+    catch (error) {
+        if (error instanceof errors_1.CliError && error.code === "AIB_CONFIG_INVALID") {
+            return node_path_1.default.resolve(cwd);
+        }
+        throw error;
+    }
+}