withub-cli 0.1.0

package/dist/commands/clone.js

@@ -0,0 +1,263 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneAction = cloneAction;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const client_1 = require("@mysten/sui/client");
+const ui_1 = require("../lib/ui");
+const walrus_1 = require("../lib/walrus");
+const suiRepo_1 = require("../lib/suiRepo");
+const schema_1 = require("../lib/schema");
+const manifest_1 = require("../lib/manifest");
+const serialize_1 = require("../lib/serialize");
+const fs_1 = require("../lib/fs");
+const state_1 = require("../lib/state");
+const repo_1 = require("../lib/repo");
+const seal_1 = require("../lib/seal");
+const keys_1 = require("../lib/keys");
+const DEFAULT_RELAYS = ['https://upload-relay.testnet.walrus.space'];
+const DEFAULT_NETWORK = 'testnet';
+async function cloneAction(repoId) {
+    if (!repoId) {
+        throw new Error('Usage: wit clone <repo_id>');
+    }
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.header('Starting clone...'));
+    // Prepare .wit layout and config
+    const witPath = await ensureLayout(process.cwd(), repoId);
+    const resolved = await (0, walrus_1.resolveWalrusConfig)(process.cwd());
+    const suiClient = new client_1.SuiClient({ url: resolved.suiRpcUrl });
+    const walrusSvc = await walrus_1.WalrusService.fromRepo();
+    const signerInfo = await (0, keys_1.loadSigner)();
+    // Fetch on-chain head
+    const onchain = await (0, suiRepo_1.fetchRepositoryStateWithRetry)(suiClient, repoId);
+    if (!onchain.headCommit || !onchain.headManifest || !onchain.headQuilt) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.yellow('Remote repository has no head. Nothing to clone.'));
+        return;
+    }
+    // Download manifest
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan('Downloading manifest...'));
+    const manifestBuf = Buffer.from(await walrusSvc.readBlob(onchain.headManifest));
+    const manifest = schema_1.ManifestSchema.parse(JSON.parse(manifestBuf.toString('utf8')));
+    const computedRoot = (0, manifest_1.computeRootHash)(Object.fromEntries(Object.entries(manifest.files).map(([rel, meta]) => [
+        rel,
+        { hash: meta.hash, size: meta.size, mode: meta.mode, mtime: meta.mtime },
+    ])));
+    if (computedRoot !== manifest.root_hash) {
+        throw new Error('Manifest root_hash mismatch; aborting clone.');
+    }
+    await cacheJson(path_1.default.join(witPath, 'objects', 'manifests', `${(0, state_1.idToFileName)(onchain.headManifest)}.json`), (0, serialize_1.canonicalStringify)(manifest));
+    // Persist repo config seal policy if present
+    if (onchain.sealPolicyId) {
+        try {
+            const cfgRaw = await promises_1.default.readFile(path_1.default.join(witPath, 'config.json'), 'utf8');
+            const cfg = JSON.parse(cfgRaw);
+            cfg.seal_policy_id = onchain.sealPolicyId;
+            await (0, repo_1.writeRepoConfig)(witPath, cfg);
+        }
+        catch {
+            // best-effort
+        }
+    }
+    const sealPolicyId = onchain.sealPolicyId || null;
+    const hasEncrypted = Object.values(manifest.files).some((meta) => meta.enc);
+    if (hasEncrypted && !sealPolicyId) {
+        throw new Error('Encrypted repository detected but no seal policy id on chain.');
+    }
+    // Download remote commit
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan('Downloading commit...'));
+    const commitBuf = Buffer.from(await walrusSvc.readBlob(onchain.headCommit));
+    const commit = parseRemoteCommit(commitBuf);
+    if (commit.tree.root_hash !== manifest.root_hash) {
+        throw new Error('Commit root_hash does not match manifest; aborting clone.');
+    }
+    await cacheJson(path_1.default.join(witPath, 'objects', 'commits', `${(0, state_1.idToFileName)(onchain.headCommit)}.json`), commitBuf.toString('utf8'));
+    // Fetch files by id
+    const entries = Object.entries(manifest.files);
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.cyan(`Downloading ${entries.length} files from Walrus...`));
+    const index = {};
+    for (let i = 0; i < entries.length; i += 1) {
+        const [rel, meta] = entries[i];
+        const data = await fetchFileBytes(walrusSvc, manifest, rel, meta);
+        let plain;
+        try {
+            if (meta.enc) {
+                // Map metadata to EncryptionMeta
+                const encAny = meta.enc;
+                const encMeta = {
+                    alg: encAny.alg || encAny.enc_alg,
+                    policy_id: encAny.policy_id || encAny.enc_policy,
+                    package_id: encAny.package_id || encAny.enc_package || '0x0', // Fallback or read from meta
+                    sealed_session_key: encAny.sealed_session_key || encAny.enc_sealed_key,
+                    iv: encAny.iv || encAny.enc_iv,
+                    tag: encAny.tag || encAny.enc_tag,
+                };
+                plain = await (0, seal_1.decryptWithSeal)(data, encMeta, signerInfo.signer, suiClient);
+            }
+            else {
+                plain = data;
+            }
+        }
+        catch (err) {
+            // Handle decryption errors gracefully
+            if (err.message?.includes('NoAccess')) {
+                // eslint-disable-next-line no-console
+                console.log(ui_1.colors.red('❌ Access denied: You are not whitelisted for this private repository.'));
+                // eslint-disable-next-line no-console
+                console.log(ui_1.colors.yellow(`   Policy ID: ${meta.enc?.policy_id || sealPolicyId}`));
+                // eslint-disable-next-line no-console
+                console.log(ui_1.colors.yellow('   Please contact the repository owner to be added to the whitelist.'));
+                process.exit(1);
+            }
+            if (err.message?.includes('Timeout')) {
+                // eslint-disable-next-line no-console
+                console.log(ui_1.colors.red('❌ Connection timeout: Unable to reach Seal decryption servers.'));
+                // eslint-disable-next-line no-console
+                console.log(ui_1.colors.yellow('   Please check your network connection and try again.'));
+                process.exit(1);
+            }
+            // For other errors, show the file that failed
+            // eslint-disable-next-line no-console
+            console.log(ui_1.colors.red(`❌ Failed to decrypt ${rel}: ${err.message}`));
+            process.exit(1);
+        }
+        const hash = (0, serialize_1.sha256Base64)(plain);
+        if (hash !== meta.hash || plain.length !== meta.size) {
+            throw new Error(`Hash/size mismatch for ${rel}`);
+        }
+        const abs = path_1.default.join(process.cwd(), rel);
+        await (0, fs_1.ensureDirForFile)(abs);
+        await promises_1.default.writeFile(abs, plain);
+        const mode = parseInt(meta.mode, 10) & 0o777;
+        await promises_1.default.chmod(abs, mode);
+        index[rel] = { hash: meta.hash, size: meta.size, mode: meta.mode, mtime: meta.mtime };
+    }
+    // Write index and refs/state
+    await (0, fs_1.writeIndex)(path_1.default.join(witPath, 'index'), index);
+    await ensureHeadFiles(witPath, onchain.headCommit);
+    await (0, repo_1.writeRemoteRef)(witPath, onchain.headCommit);
+    await (0, repo_1.writeRemoteState)(witPath, {
+        repo_id: repoId,
+        head_commit: onchain.headCommit,
+        head_manifest: onchain.headManifest,
+        head_quilt: onchain.headQuilt,
+        version: onchain.version,
+    });
+    const commitMap = await readCommitIdMapSafe(witPath);
+    await downloadCommitChain(walrusSvc, onchain.headCommit, witPath, commitMap);
+    await (0, state_1.writeCommitIdMap)(witPath, commitMap);
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.green('Clone complete.'));
+    // eslint-disable-next-line no-console
+    console.log(`Head: ${ui_1.colors.hash(onchain.headCommit)}`);
+    // eslint-disable-next-line no-console
+    console.log(`Manifest: ${ui_1.colors.hash(onchain.headManifest)}`);
+    // eslint-disable-next-line no-console
+    console.log(`Quilt: ${ui_1.colors.hash(onchain.headQuilt)}`);
+}
+async function fetchFileBytes(walrusSvc, manifest, rel, meta) {
+    // Prefer quilt fetch when quilt_id is present; fallback to direct file id
+    if (manifest.quilt_id) {
+        try {
+            const bytes = await walrusSvc.readQuiltFile(manifest.quilt_id, rel);
+            return Buffer.from(bytes);
+        }
+        catch (err) {
+            // fallback to direct id path below
+        }
+    }
+    if (meta.id) {
+        const files = await walrusSvc.getClient().getFiles({ ids: [meta.id] });
+        const file = files[0];
+        const data = Buffer.from(await file.bytes());
+        const tags = await file.getTags();
+        if (tags?.hash && tags.hash !== meta.hash) {
+            throw new Error(`Tag hash mismatch for ${rel}`);
+        }
+        return data;
+    }
+    throw new Error(`Manifest entry missing file id for ${rel}`);
+}
+async function ensureLayout(cwd, repoId) {
+    const witPath = path_1.default.join(cwd, '.wit');
+    await promises_1.default.mkdir(witPath, { recursive: true });
+    const subdirs = [
+        'refs/heads',
+        'refs/remotes',
+        'objects/blobs',
+        'objects/commits',
+        'objects/manifests',
+        'objects/quilts',
+        'objects/maps',
+        'state',
+    ];
+    await Promise.all(subdirs.map((d) => promises_1.default.mkdir(path_1.default.join(witPath, d), { recursive: true })));
+    const cfgPath = path_1.default.join(witPath, 'config.json');
+    try {
+        await promises_1.default.access(cfgPath);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT') {
+            const cfg = {
+                repo_name: repoId,
+                repo_id: repoId,
+                network: DEFAULT_NETWORK,
+                relays: DEFAULT_RELAYS,
+                author: 'unknown',
+                key_alias: 'default',
+                seal_policy_id: null,
+                created_at: new Date().toISOString(),
+            };
+            await (0, repo_1.writeRepoConfig)(witPath, cfg);
+        }
+        else {
+            throw err;
+        }
+    }
+    await promises_1.default.writeFile(path_1.default.join(witPath, 'HEAD'), 'refs/heads/main\n', 'utf8');
+    return witPath;
+}
+async function ensureHeadFiles(witPath, headCommit) {
+    const headRefPath = path_1.default.join(witPath, 'refs', 'heads', 'main');
+    await promises_1.default.writeFile(headRefPath, `${headCommit}\n`, 'utf8');
+}
+function parseRemoteCommit(buf) {
+    const parsed = JSON.parse(buf.toString('utf8'));
+    if (!parsed?.tree?.root_hash || !parsed?.tree?.manifest_id) {
+        throw new Error('Invalid remote commit object');
+    }
+    return parsed;
+}
+async function cacheJson(filePath, content) {
+    await (0, fs_1.ensureDirForFile)(filePath);
+    await promises_1.default.writeFile(filePath, content, 'utf8');
+}
+async function readCommitIdMapSafe(witPath) {
+    try {
+        return await (0, state_1.readCommitIdMap)(witPath);
+    }
+    catch {
+        return {};
+    }
+}
+async function downloadCommitChain(walrusSvc, startId, witPath, map) {
+    const seen = new Set();
+    let current = startId;
+    while (current && !seen.has(current)) {
+        seen.add(current);
+        const buf = Buffer.from(await walrusSvc.readBlob(current));
+        const commit = parseRemoteCommit(buf);
+        await cacheJson(path_1.default.join(witPath, 'objects', 'commits', `${(0, state_1.idToFileName)(current)}.json`), buf.toString('utf8'));
+        if (!map[current]) {
+            map[current] = current;
+        }
+        current = commit.parent;
+    }
+}

package/dist/commands/commit.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commitAction = commitAction;
+exports.logAction = logAction;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const serialize_1 = require("../lib/serialize");
+const fs_1 = require("../lib/fs");
+const state_1 = require("../lib/state");
+const repo_1 = require("../lib/repo");
+const manifest_1 = require("../lib/manifest");
+const ui_1 = require("../lib/ui");
+const WIT_DIR = '.wit';
+async function commitAction(opts) {
+    const message = opts.message;
+    if (!message) {
+        throw new Error('Commit message is required (use -m/--message).');
+    }
+    const witPath = await requireWitDir();
+    const indexPath = path_1.default.join(witPath, 'index');
+    const index = await (0, fs_1.readIndex)(indexPath);
+    if (Object.keys(index).length === 0) {
+        // eslint-disable-next-line no-console
+        console.warn('Index is empty. Nothing to commit.');
+        return;
+    }
+    const config = await readConfig(witPath);
+    if (!config.author || config.author === 'unknown') {
+        // eslint-disable-next-line no-console
+        console.warn(ui_1.colors.yellow('Warning: author is unknown. Set author in .wit/config.json or ~/.witconfig.'));
+    }
+    const headRefPath = await (0, state_1.readHeadRefPath)(witPath);
+    const parent = await (0, state_1.readRef)(headRefPath);
+    const rootHash = (0, manifest_1.computeRootHash)(index);
+    const commit = {
+        tree: {
+            root_hash: rootHash,
+            manifest_id: null,
+            quilt_id: null,
+            files: index,
+        },
+        parent,
+        author: config.author || 'unknown',
+        message,
+        timestamp: Math.floor(Date.now() / 1000),
+        extras: { patch_id: null, tags: {} },
+    };
+    const serialized = (0, serialize_1.canonicalStringify)(commit);
+    const commitId = (0, serialize_1.sha256Base64)(serialized);
+    await writeCommitObject(witPath, commitId, serialized);
+    await promises_1.default.writeFile(headRefPath, `${commitId}\n`, 'utf8');
+    await updateCommitMap(witPath, commitId);
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.green(`Committed ${commitId}`));
+}
+async function logAction() {
+    const witPath = await requireWitDir();
+    const headRefPath = await (0, state_1.readHeadRefPath)(witPath);
+    const head = await (0, state_1.readRef)(headRefPath);
+    const remoteHead = await (0, repo_1.readRemoteRef)(witPath);
+    const commitMap = await (0, state_1.readCommitIdMap)(witPath);
+    // If the local HEAD has already been pushed and maps to remoteHead, treat it as the same commit.
+    const headRemoteMapped = head ? commitMap[head] : null;
+    const remoteAligned = head && remoteHead && headRemoteMapped === remoteHead;
+    const seen = new Set();
+    if (head) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.header('Local (HEAD):'));
+        let currentId = head;
+        while (currentId) {
+            const commit = await readCommit(witPath, currentId);
+            printCommit(currentId, commit);
+            seen.add(currentId);
+            currentId = commit.parent;
+        }
+        if (remoteAligned) {
+            // eslint-disable-next-line no-console
+            console.log(ui_1.colors.gray(`(remote id: ${ui_1.colors.hash(remoteHead)})`));
+        }
+    }
+    else {
+        // eslint-disable-next-line no-console
+        console.log('No local commits yet.');
+    }
+    if (remoteHead && (!head || remoteHead !== head) && !remoteAligned) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.header('Remote (remotes/main):'));
+        let currentId = remoteHead;
+        while (currentId && !seen.has(currentId)) {
+            const commit = await readCommit(witPath, currentId);
+            printCommit(currentId, commit);
+            seen.add(currentId);
+            currentId = commit.parent;
+        }
+    }
+}
+async function requireWitDir() {
+    const dir = path_1.default.join(process.cwd(), WIT_DIR);
+    try {
+        await promises_1.default.access(dir);
+        return dir;
+    }
+    catch {
+        throw new Error('Not a wit repository (missing .wit). Run `wit init` first.');
+    }
+}
+async function readConfig(witPath) {
+    const file = path_1.default.join(witPath, 'config.json');
+    try {
+        const raw = await promises_1.default.readFile(file, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT') {
+            return {};
+        }
+        throw err;
+    }
+}
+async function writeCommitObject(witPath, commitId, serialized) {
+    const file = path_1.default.join(witPath, 'objects', 'commits', `${(0, state_1.idToFileName)(commitId)}.json`);
+    await promises_1.default.writeFile(file, serialized, 'utf8');
+}
+async function readCommit(witPath, commitId) {
+    return (0, state_1.readCommitById)(witPath, commitId);
+}
+function printCommit(id, commit) {
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.header(`commit ${ui_1.colors.hash(id)}`));
+    // eslint-disable-next-line no-console
+    console.log(`Author: ${ui_1.colors.author(commit.author)}`);
+    // eslint-disable-next-line no-console
+    console.log(`Date:   ${ui_1.colors.date(new Date(commit.timestamp * 1000).toISOString())}`);
+    // eslint-disable-next-line no-console
+    console.log();
+    // eslint-disable-next-line no-console
+    console.log(`    ${commit.message}`);
+    // eslint-disable-next-line no-console
+    console.log();
+}
+async function updateCommitMap(witPath, commitId) {
+    const map = await (0, state_1.readCommitIdMap)(witPath);
+    if (!map[commitId]) {
+        map[commitId] = null;
+        await (0, state_1.writeCommitIdMap)(witPath, map);
+    }
+}

package/dist/commands/diff.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffAction = diffAction;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const diff_1 = require("diff");
+const isbinaryfile_1 = require("isbinaryfile");
+const fs_1 = require("../lib/fs");
+const state_1 = require("../lib/state");
+const ui_1 = require("../lib/ui");
+const WIT_DIR = '.wit';
+async function diffAction(opts) {
+    const cwd = process.cwd();
+    const witPath = await requireWitDir();
+    const indexPath = path_1.default.join(witPath, 'index');
+    const index = await (0, fs_1.readIndex)(indexPath);
+    if (opts.cached) {
+        const headRefPath = await (0, state_1.readHeadRefPath)(witPath);
+        const headId = await (0, state_1.readRef)(headRefPath);
+        if (!headId) {
+            // eslint-disable-next-line no-console
+            console.warn('No commits to diff against.');
+            return;
+        }
+        const commit = await (0, state_1.readCommitById)(witPath, headId);
+        const changes = await diffIndex(commit.tree.files, index, {
+            loadBase: (rel, meta) => (0, fs_1.readBlob)(witPath, meta.hash),
+            loadTarget: (rel, meta) => (0, fs_1.readBlob)(witPath, meta.hash),
+            baseLabel: 'HEAD',
+            targetLabel: 'index',
+            cwd,
+        });
+        printChanges('index vs HEAD', changes);
+    }
+    else {
+        const tracked = new Set(Object.keys(index));
+        const ig = await (0, fs_1.buildIgnore)(cwd);
+        const workspaceFiles = await (0, fs_1.walkFiles)(cwd, ig, cwd, tracked);
+        const workspaceMeta = {};
+        for (const file of workspaceFiles) {
+            const rel = (0, fs_1.pathToPosix)(path_1.default.relative(cwd, file));
+            workspaceMeta[rel] = await (0, fs_1.computeFileMeta)(file);
+        }
+        const changes = await diffIndex(index, workspaceMeta, {
+            loadBase: (rel, meta) => (0, fs_1.readBlob)(witPath, meta.hash),
+            loadTarget: async (rel) => {
+                try {
+                    return await promises_1.default.readFile(path_1.default.join(cwd, rel));
+                }
+                catch (err) {
+                    if (err?.code === 'ENOENT')
+                        return null;
+                    throw err;
+                }
+            },
+            baseLabel: 'index',
+            targetLabel: 'worktree',
+            cwd,
+        });
+        printChanges('worktree vs index', changes);
+    }
+}
+async function diffIndex(base, target, ctx) {
+    const changes = [];
+    const paths = new Set([...Object.keys(base), ...Object.keys(target)]);
+    for (const rel of Array.from(paths).sort()) {
+        const a = base[rel];
+        const b = target[rel];
+        if (!a && b) {
+            const targetBuf = await ctx.loadTarget(rel, b);
+            const binary = await isBinaryBuffers(undefined, targetBuf);
+            const patch = binary ? undefined : createPatch(rel, '', targetBuf?.toString('utf8') ?? '', ctx.baseLabel, ctx.targetLabel);
+            changes.push({ path: rel, kind: 'A', binary, patch });
+        }
+        else if (a && !b) {
+            const baseBuf = await ctx.loadBase(rel, a);
+            const binary = await isBinaryBuffers(baseBuf, undefined);
+            const patch = binary ? undefined : createPatch(rel, baseBuf?.toString('utf8') ?? '', '', ctx.baseLabel, ctx.targetLabel);
+            changes.push({ path: rel, kind: 'D', binary, patch });
+        }
+        else if (a && b && !sameMeta(a, b)) {
+            const baseBuf = await ctx.loadBase(rel, a);
+            const targetBuf = await ctx.loadTarget(rel, b);
+            const binary = await isBinaryBuffers(baseBuf, targetBuf);
+            const patch = binary
+                ? undefined
+                : createPatch(rel, baseBuf?.toString('utf8') ?? '', targetBuf?.toString('utf8') ?? '', ctx.baseLabel, ctx.targetLabel);
+            changes.push({ path: rel, kind: 'M', binary, patch });
+        }
+    }
+    return changes;
+}
+function sameMeta(a, b) {
+    return a.hash === b.hash && a.size === b.size && a.mode === b.mode;
+}
+async function isBinaryBuffers(a, b) {
+    const checks = [a, b];
+    for (const buf of checks) {
+        if (!buf)
+            continue;
+        try {
+            if (await (0, isbinaryfile_1.isBinaryFile)(buf))
+                return true;
+        }
+        catch {
+            // fallback silent; continue to next buffer
+        }
+    }
+    return false;
+}
+function printChanges(title, changes) {
+    if (!changes.length) {
+        // eslint-disable-next-line no-console
+        console.log('No differences.');
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log(ui_1.colors.header(`# Diff (${title})`));
+    changes.forEach((c) => {
+        const kindLabel = c.kind === 'A' ? 'Added' : c.kind === 'D' ? 'Deleted' : 'Modified';
+        const binaryLabel = c.binary ? 'binary' : 'text';
+        const color = c.kind === 'A' ? ui_1.colors.green : c.kind === 'D' ? ui_1.colors.red : ui_1.colors.yellow;
+        // eslint-disable-next-line no-console
+        console.log(color(`${c.kind}\t[${binaryLabel}]\t${c.path}\t${kindLabel}`));
+        if (!c.binary && c.patch) {
+            console.log(formatPatch(c.patch));
+        }
+    });
+}
+function formatPatch(patch) {
+    return patch
+        .split('\n')
+        .map((line) => {
+        if (line.startsWith('+'))
+            return ui_1.colors.green(line);
+        if (line.startsWith('-'))
+            return ui_1.colors.red(line);
+        if (line.startsWith('@@'))
+            return ui_1.colors.cyan(line);
+        return line;
+    })
+        .join('\n');
+}
+function createPatch(rel, a, b, aLabel, bLabel) {
+    return (0, diff_1.createTwoFilesPatch)(`${aLabel}:${rel}`, `${bLabel}:${rel}`, a, b, undefined, undefined, { context: 3 });
+}
+async function requireWitDir() {
+    const dir = path_1.default.join(process.cwd(), WIT_DIR);
+    try {
+        await promises_1.default.access(dir);
+        return dir;
+    }
+    catch {
+        throw new Error('Not a wit repository (missing .wit). Run `wit init` first.');
+    }
+}