@aiwg/cli 2026.10.3 → 2026.10.5

package/dist/src/artifacts/framework-index-paths.js

@@ -0,0 +1,73 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+export const FRAMEWORK_CORPUS_KINDS = ['frameworks', 'addons', 'extensions', 'agents', 'behaviors'];
+function canonicalPath(candidate) {
+    try {
+        return fs.realpathSync(candidate);
+    }
+    catch {
+        return path.resolve(candidate);
+    }
+}
+/** Only an AIWG package/repository owns the corpus, never a project or bundle. */
+export function resolveFrameworkCorpusRoot(candidate) {
+    let root = canonicalPath(candidate);
+    while (true) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+            if (pkg.name === 'aiwg' && FRAMEWORK_CORPUS_KINDS.every(kind => fs.statSync(path.join(root, 'agentic/code', kind)).isDirectory()))
+                return canonicalPath(root);
+        }
+        catch { /* keep looking for the owning package */ }
+        const parent = path.dirname(root);
+        if (parent === root)
+            return null;
+        root = parent;
+    }
+}
+/** Works in both src/ and dist/src/, including corpus-free CLI packages. */
+function modulePackageRoot() {
+    let root = path.dirname(fileURLToPath(import.meta.url));
+    while (true) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+            if (pkg.name === 'aiwg' || pkg.name === '@aiwg/cli')
+                return canonicalPath(root);
+        }
+        catch { /* keep looking for the owning distribution */ }
+        const parent = path.dirname(root);
+        if (parent === root)
+            throw new Error('Cannot resolve the AIWG package root for the framework index');
+        root = parent;
+    }
+}
+/** Builders, readers and reconciliation must select the same owning root. */
+export function resolveFrameworkIndexRoot(cwd) {
+    return resolveFrameworkCorpusRoot(cwd)
+        ?? (process.env.AIWG_ROOT
+            ? resolveFrameworkCorpusRoot(process.env.AIWG_ROOT) ?? canonicalPath(process.env.AIWG_ROOT)
+            : modulePackageRoot());
+}
+/**
+ * Shared across projects using this package, isolated from other AIWG roots.
+ * Keep the key stable across upgrades: the fingerprint receipt handles source
+ * changes, avoiding abandoned directories for every version/commit. All graph
+ * sidecars (including relationships) belong beneath this root's framework dir.
+ * Legacy unkeyed indexes are left alone; reconciliation builds once here.
+ */
+export function getFrameworkIndexBaseDir(cwd) {
+    const root = resolveFrameworkIndexRoot(cwd);
+    const key = createHash('sha256').update(root).digest('hex');
+    // A lane may share the immutable checkout corpus across isolated homes.
+    // Restrict the override to its declared source: fixture/package roots,
+    // project graphs and user graphs retain their normal isolation.
+    const shared = process.env.AIWG_FRAMEWORK_INDEX_CACHE;
+    const source = process.env.AIWG_FRAMEWORK_INDEX_CACHE_SOURCE;
+    const xdgData = shared && source && canonicalPath(source) === root
+        ? shared : process.env.XDG_DATA_HOME ?? path.join(os.homedir(), '.local', 'share');
+    return path.join(xdgData, 'aiwg', 'index', 'roots', key);
+}
+//# sourceMappingURL=framework-index-paths.js.map

package/dist/src/artifacts/framework-source-digest.js

@@ -0,0 +1,75 @@
+/** Portable corpus identity; stat receipts are isolated by the #3310 root key. */
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { BUILTIN_GRAPH_CONFIGS, INDEX_EXTRACTOR_VERSION, getGraphIndexDir } from './types.js';
+export const FRAMEWORK_RELATIONS_REVISION = 3;
+const REVISION = FRAMEWORK_RELATIONS_REVISION;
+const sha256 = (value) => createHash('sha256').update(value).digest('hex');
+/** No absolute paths, git revision or mtimes enter the portable digest. */
+export function frameworkSourceDigest(root, cache = true) {
+    const receiptPath = path.join(getGraphIndexDir(root, 'framework'), 'relationship-sources.json');
+    let previous;
+    if (cache) {
+        try {
+            const receipt = JSON.parse(fs.readFileSync(receiptPath, 'utf8'));
+            if (receipt.version === REVISION && receipt.files && typeof receipt.files === 'object')
+                previous = receipt;
+        }
+        catch { /* cold/corrupt root receipt */ }
+    }
+    const files = {};
+    const config = BUILTIN_GRAPH_CONFIGS.framework;
+    const walk = (dir, extensions = config.extensions) => {
+        let children;
+        try {
+            children = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const child of children) {
+            if (child.name.startsWith('.') || child.isSymbolicLink())
+                continue;
+            const file = path.join(dir, child.name);
+            if (child.isDirectory())
+                walk(file, extensions);
+            else if (child.isFile() && extensions.some(ext => child.name.endsWith(ext))
+                // These development-only corpus files are excluded by package.files.
+                && !/^(package(?:-lock)?|tsconfig)\.json$/.test(child.name))
+                add(file);
+        }
+    };
+    const add = (file, logicalPath) => {
+        const relative = logicalPath ?? path.relative(root, file).split(path.sep).join('/');
+        const stat = fs.statSync(file);
+        const signature = `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
+        const old = previous?.version === REVISION ? previous.files[relative] : undefined;
+        files[relative] = { stat: signature, checksum: old?.stat === signature && /^[a-f0-9]{64}$/.test(old.checksum) ? old.checksum : sha256(fs.readFileSync(file)) };
+    };
+    for (const dir of config.scanDirs)
+        walk(path.join(root, dir));
+    // Provider configuration and projection logic are inputs to the resolved table.
+    walk(path.join(root, 'schemas/providers'));
+    walk(path.join(root, 'tools/agents/providers'), ['.mjs']);
+    // The source .mjs is copied verbatim into dist/; use one logical input key
+    // so a packed install and its checkout have exactly the same digest.
+    const activationKey = 'src/rules/activation.mjs';
+    const activation = [path.join(root, activationKey), path.join(root, 'dist', activationKey)]
+        .find(file => fs.existsSync(file));
+    if (activation)
+        add(activation, activationKey);
+    const sources = Object.keys(files).sort().map(file => [file, files[file].checksum]);
+    const digest = `sha256:${sha256(JSON.stringify({ revision: REVISION, extractor: INDEX_EXTRACTOR_VERSION, config, sources }))}`;
+    if (cache) {
+        const text = JSON.stringify({ version: REVISION, files });
+        if (text !== JSON.stringify(previous)) {
+            fs.mkdirSync(path.dirname(receiptPath), { recursive: true });
+            const temp = `${receiptPath}.${process.pid}.tmp`;
+            fs.writeFileSync(temp, text);
+            fs.renameSync(temp, receiptPath);
+        }
+    }
+    return digest;
+}
+//# sourceMappingURL=framework-source-digest.js.map