@bbigbang/agent-node 0.1.0

package/dist/hostRuntime.js

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

package/dist/libraryAuthorityFs.js

@@ -0,0 +1,74 @@
+import fs from 'node:fs';
+import path from 'node:path';
+function normalizeLibraryRelativePath(rawPath) {
+    const trimmed = rawPath.trim().replace(/\\/g, '/');
+    const normalized = path.posix.normalize(trimmed).replace(/^\/+/, '').replace(/\/+$/, '');
+    if (!normalized
+        || normalized === '.'
+        || normalized === '..'
+        || normalized.startsWith('../')
+        || normalized.includes('/../')) {
+        throw new Error('Invalid library path');
+    }
+    return normalized;
+}
+export function deleteLibraryAuthorityPath(libraryRootPath, relativePath, options) {
+    const normalizedPath = normalizeLibraryRelativePath(relativePath);
+    const libraryRoot = path.resolve(libraryRootPath);
+    const absolutePath = path.resolve(libraryRoot, normalizedPath);
+    if (absolutePath !== libraryRoot && !absolutePath.startsWith(`${libraryRoot}${path.sep}`)) {
+        throw new Error('Invalid library path');
+    }
+    const stat = fs.lstatSync(absolutePath, { throwIfNoEntry: false });
+    if (!stat)
+        return;
+    if (stat.isDirectory()) {
+        if (!options?.recursive) {
+            throw new Error('Directory deletion requires recursive=true');
+        }
+        fs.rmSync(absolutePath, { recursive: true, force: true });
+    }
+    else {
+        fs.rmSync(absolutePath, { force: true });
+    }
+    let cursor = path.dirname(absolutePath);
+    while (cursor.startsWith(libraryRoot) && cursor !== libraryRoot) {
+        const remaining = fs.readdirSync(cursor);
+        if (remaining.length > 0)
+            break;
+        fs.rmdirSync(cursor);
+        cursor = path.dirname(cursor);
+    }
+}
+export function renameLibraryAuthorityPath(libraryRootPath, relativePath, nextRelativePath) {
+    const normalizedPath = normalizeLibraryRelativePath(relativePath);
+    const normalizedNextPath = normalizeLibraryRelativePath(nextRelativePath);
+    const libraryRoot = path.resolve(libraryRootPath);
+    const absolutePath = path.resolve(libraryRoot, normalizedPath);
+    const absoluteNextPath = path.resolve(libraryRoot, normalizedNextPath);
+    if ((absolutePath !== libraryRoot && !absolutePath.startsWith(`${libraryRoot}${path.sep}`))
+        || (absoluteNextPath !== libraryRoot && !absoluteNextPath.startsWith(`${libraryRoot}${path.sep}`))) {
+        throw new Error('Invalid library path');
+    }
+    if (absolutePath === absoluteNextPath) {
+        throw new Error('Source and destination paths are the same');
+    }
+    const sourceStat = fs.lstatSync(absolutePath, { throwIfNoEntry: false });
+    if (!sourceStat) {
+        throw new Error('Path not found');
+    }
+    const targetStat = fs.lstatSync(absoluteNextPath, { throwIfNoEntry: false });
+    if (targetStat) {
+        throw new Error('Destination already exists');
+    }
+    fs.mkdirSync(path.dirname(absoluteNextPath), { recursive: true });
+    fs.renameSync(absolutePath, absoluteNextPath);
+    let cursor = path.dirname(absolutePath);
+    while (cursor.startsWith(libraryRoot) && cursor !== libraryRoot) {
+        const remaining = fs.readdirSync(cursor);
+        if (remaining.length > 0)
+            break;
+        fs.rmdirSync(cursor);
+        cursor = path.dirname(cursor);
+    }
+}

package/dist/libraryMirror.js

@@ -0,0 +1,183 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+const LIBRARY_ROOT_DIRECTORY = '.library';
+const MANAGED_MARKER_FILE = '.bigbang-managed.json';
+const AGENT_COLLAB_MANAGED_MARKER_FILE = '.agent-collab-managed.json';
+const LEGACY_MANAGED_MARKER_FILE = '.managed-by-bigbang';
+const SHARED_README_FILE = 'README.txt';
+const SHARED_README_CONTENT = [
+    'Shared library workspace',
+    '',
+    'Shared documents are mounted in this directory at .library/shared.',
+    '',
+    'Usage rules:',
+    '- Inspect the directory and any relevant existing documents before modifying shared documents.',
+    '- For ordinary parallel task-thread work, prefer creating a unique markdown file for your contribution, such as a filename containing your agent name or the date.',
+    '- Update an existing markdown document only when the user explicitly asks for that file or the task clearly assigns one shared file to maintain.',
+    '- Do not edit .meta/manifest.json, INDEX.md, README.txt, or generated index/metadata files.',
+    '- Do not have multiple agents concurrently maintain the same index.md file unless the task thread explicitly assigns that coordination pattern.',
+    '- The platform rebuilds shared library manifest/index metadata after writeback.',
+    '- If several agents must update the same shared document, agree on ownership and merge order in the task thread first.',
+    '',
+].join('\n');
+const MANAGED_TOP_LEVEL_ENTRIES = new Set([
+    MANAGED_MARKER_FILE,
+    AGENT_COLLAB_MANAGED_MARKER_FILE,
+    LEGACY_MANAGED_MARKER_FILE,
+    'shared',
+    'personal',
+]);
+export function applyLibraryMirror(workspaceRoot, mirror) {
+    const managedRootPath = ensureManagedLibraryRoot(workspaceRoot);
+    pruneUnexpectedManagedEntries(managedRootPath);
+    applyScopeTree(managedRootPath, 'shared', mirror.shared);
+    writeSharedReadmeIfNeeded(managedRootPath, mirror.shared);
+    applyScopeTree(managedRootPath, 'personal', mirror.personal);
+    writeManagedMarker(managedRootPath);
+}
+export function snapshotLibraryMirror(workspaceRoot) {
+    const managedRootPath = path.join(path.resolve(workspaceRoot), LIBRARY_ROOT_DIRECTORY);
+    const rootStat = fs.lstatSync(managedRootPath, { throwIfNoEntry: false });
+    if (!rootStat) {
+        return { shared: null, personal: null };
+    }
+    if (!rootStat.isDirectory()) {
+        throw new Error(`[libraryMirror] expected managed directory at ${managedRootPath}`);
+    }
+    if (!isManagedLibraryDirectory(managedRootPath)) {
+        throw new Error(`[libraryMirror] refusing to snapshot unmanaged library directory at ${managedRootPath}`);
+    }
+    return {
+        shared: collectScopeTree(managedRootPath, 'shared'),
+        personal: collectScopeTree(managedRootPath, 'personal'),
+    };
+}
+function ensureManagedLibraryRoot(workspaceRoot) {
+    const managedRootPath = path.join(path.resolve(workspaceRoot), LIBRARY_ROOT_DIRECTORY);
+    const rootStat = fs.lstatSync(managedRootPath, { throwIfNoEntry: false });
+    if (!rootStat) {
+        fs.mkdirSync(managedRootPath, { recursive: true });
+        writeManagedMarker(managedRootPath);
+        return managedRootPath;
+    }
+    if (rootStat.isSymbolicLink()) {
+        fs.unlinkSync(managedRootPath);
+        fs.mkdirSync(managedRootPath, { recursive: true });
+        writeManagedMarker(managedRootPath);
+        return managedRootPath;
+    }
+    if (!rootStat.isDirectory()) {
+        throw new Error(`[libraryMirror] refusing to replace existing file at ${managedRootPath}`);
+    }
+    if (!isManagedLibraryDirectory(managedRootPath)) {
+        throw new Error(`[libraryMirror] refusing to replace existing directory at ${managedRootPath}`);
+    }
+    for (const legacyMarkerPath of [
+        path.join(managedRootPath, AGENT_COLLAB_MANAGED_MARKER_FILE),
+        path.join(managedRootPath, LEGACY_MANAGED_MARKER_FILE),
+    ]) {
+        if (fs.existsSync(legacyMarkerPath)) {
+            fs.rmSync(legacyMarkerPath, { force: true });
+        }
+    }
+    writeManagedMarker(managedRootPath);
+    return managedRootPath;
+}
+function isManagedLibraryDirectory(managedRootPath) {
+    return fs.existsSync(path.join(managedRootPath, MANAGED_MARKER_FILE))
+        || fs.existsSync(path.join(managedRootPath, AGENT_COLLAB_MANAGED_MARKER_FILE))
+        || fs.existsSync(path.join(managedRootPath, LEGACY_MANAGED_MARKER_FILE));
+}
+function writeManagedMarker(managedRootPath) {
+    fs.writeFileSync(path.join(managedRootPath, MANAGED_MARKER_FILE), JSON.stringify({
+        kind: 'library_mirror',
+        version: 1,
+    }, null, 2) + '\n', 'utf8');
+}
+function pruneUnexpectedManagedEntries(managedRootPath) {
+    for (const entry of fs.readdirSync(managedRootPath, { withFileTypes: true })) {
+        if (MANAGED_TOP_LEVEL_ENTRIES.has(entry.name))
+            continue;
+        fs.rmSync(path.join(managedRootPath, entry.name), { recursive: true, force: true });
+    }
+}
+function applyScopeTree(managedRootPath, scopeName, tree) {
+    const scopeRootPath = path.join(managedRootPath, scopeName);
+    fs.rmSync(scopeRootPath, { recursive: true, force: true });
+    if (!tree)
+        return;
+    fs.mkdirSync(scopeRootPath, { recursive: true });
+    for (const file of tree.files) {
+        const normalizedPath = normalizeMirrorRelativePath(file.path);
+        const normalizedContent = file.content.replace(/\r\n/g, '\n');
+        const actualSha = sha256(normalizedContent);
+        if (actualSha !== file.sha256) {
+            throw new Error(`[libraryMirror] checksum mismatch for ${scopeName}/${normalizedPath}`);
+        }
+        const absolutePath = path.join(scopeRootPath, normalizedPath);
+        fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+        fs.writeFileSync(absolutePath, normalizedContent, 'utf8');
+    }
+}
+function writeSharedReadmeIfNeeded(managedRootPath, sharedTree) {
+    if (!sharedTree)
+        return;
+    const sharedRootPath = path.join(managedRootPath, 'shared');
+    fs.writeFileSync(path.join(sharedRootPath, SHARED_README_FILE), SHARED_README_CONTENT, 'utf8');
+}
+function collectScopeTree(managedRootPath, scopeName) {
+    const scopeRootPath = path.join(managedRootPath, scopeName);
+    const stat = fs.lstatSync(scopeRootPath, { throwIfNoEntry: false });
+    if (!stat)
+        return null;
+    if (!stat.isDirectory()) {
+        throw new Error(`[libraryMirror] expected directory at ${scopeRootPath}`);
+    }
+    const files = [];
+    collectScopeFiles(scopeRootPath, scopeName, '', files);
+    return {
+        files: files.sort((left, right) => left.path.localeCompare(right.path)),
+    };
+}
+function collectScopeFiles(scopeRootPath, scopeName, relativePrefix, files) {
+    const entries = fs
+        .readdirSync(path.join(scopeRootPath, relativePrefix), { withFileTypes: true })
+        .sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+        const relativePath = relativePrefix ? path.posix.join(relativePrefix, entry.name) : entry.name;
+        const absolutePath = path.join(scopeRootPath, relativePath);
+        if (entry.isSymbolicLink()) {
+            throw new Error(`[libraryMirror] refusing to snapshot symlink at ${absolutePath}`);
+        }
+        if (entry.isDirectory()) {
+            collectScopeFiles(scopeRootPath, scopeName, relativePath, files);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if (scopeName === 'shared' && relativePath === SHARED_README_FILE)
+            continue;
+        const content = fs.readFileSync(absolutePath, 'utf8').replace(/\r\n/g, '\n');
+        files.push({
+            path: relativePath,
+            content,
+            sha256: sha256(content),
+        });
+    }
+}
+function normalizeMirrorRelativePath(rawPath) {
+    const trimmed = rawPath.trim().replace(/\\/g, '/');
+    const normalized = path.posix.normalize(trimmed).replace(/^\/+/, '').replace(/\/+$/, '');
+    if (!normalized
+        || normalized === '.'
+        || normalized === '..'
+        || normalized.startsWith('../')
+        || normalized.includes('/../')) {
+        throw new Error(`Invalid library mirror path: ${rawPath}`);
+    }
+    return normalized;
+}
+function sha256(content) {
+    return createHash('sha256').update(content, 'utf8').digest('hex');
+}