withub-cli 0.1.0

package/dist/commands/workspace.js

@@ -0,0 +1,260 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusAction = statusAction;
+exports.addAction = addAction;
+exports.resetAction = resetAction;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("../lib/fs");
+const ui_1 = require("../lib/ui");
+const WIT_DIR = '.wit';
+async function statusAction() {
+    const witPath = await requireWitDir();
+    const indexPath = path_1.default.join(witPath, 'index');
+    const index = await (0, fs_1.readIndex)(indexPath);
+    const tracked = new Set(Object.keys(index));
+    const ig = await (0, fs_1.buildIgnore)(process.cwd());
+    const workspaceFiles = await (0, fs_1.walkFiles)(process.cwd(), ig, process.cwd(), tracked);
+    const workspaceMeta = {};
+    for (const file of workspaceFiles) {
+        const rel = (0, fs_1.pathToPosix)(path_1.default.relative(process.cwd(), file));
+        workspaceMeta[rel] = await computeMetaWithCache(file, rel, index);
+    }
+    const untracked = [];
+    const modified = [];
+    const deleted = [];
+    for (const [rel, meta] of Object.entries(workspaceMeta)) {
+        const indexed = index[rel];
+        if (!indexed) {
+            untracked.push(rel);
+        }
+        else if (!sameMeta(indexed, meta)) {
+            modified.push(rel);
+        }
+    }
+    for (const rel of Object.keys(index)) {
+        if (!workspaceMeta[rel]) {
+            deleted.push(rel);
+        }
+    }
+    printStatus({ untracked, modified, deleted });
+}
+async function addAction(paths, opts) {
+    const witPath = await requireWitDir();
+    const indexPath = path_1.default.join(witPath, 'index');
+    const index = await (0, fs_1.readIndex)(indexPath);
+    const ig = await (0, fs_1.buildIgnore)(process.cwd());
+    const targets = await collectTargets(resolveAddTargets(paths, opts));
+    const targetRelSet = new Set(targets.map((t) => t.rel));
+    const filesToAdd = new Set();
+    for (const target of targets) {
+        if ((0, fs_1.shouldIgnore)(ig, target.rel, target.isDir)) {
+            // eslint-disable-next-line no-console
+            console.warn(`Ignored by patterns: ${target.rel}`);
+            continue;
+        }
+        if (target.isDir) {
+            const nested = await (0, fs_1.walkFiles)(target.abs, ig, process.cwd());
+            nested.forEach((file) => filesToAdd.add(file));
+        }
+        else {
+            filesToAdd.add(target.abs);
+        }
+    }
+    for (const file of filesToAdd) {
+        const rel = (0, fs_1.pathToPosix)(path_1.default.relative(process.cwd(), file));
+        const meta = await (0, fs_1.computeFileMeta)(file);
+        index[rel] = meta;
+        await (0, fs_1.ensureBlobFromFile)(witPath, meta.hash, file);
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.added(`added ${rel}`));
+    }
+    const deletions = [];
+    for (const rel of Object.keys(index)) {
+        if (!isWithinTargets(rel, targetRelSet))
+            continue;
+        const absPath = path_1.default.join(process.cwd(), rel);
+        try {
+            await promises_1.default.stat(absPath);
+        }
+        catch (err) {
+            if (err?.code === 'ENOENT') {
+                delete index[rel];
+                deletions.push(rel);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    await (0, fs_1.writeIndex)(indexPath, index);
+    deletions.forEach((rel) => console.log(ui_1.colors.deleted(`removed ${rel}`)));
+}
+async function resetAction(paths, opts) {
+    const witPath = await requireWitDir();
+    const indexPath = path_1.default.join(witPath, 'index');
+    const index = await (0, fs_1.readIndex)(indexPath);
+    if (opts?.staged === false) {
+        return restoreWorktree(paths, index, witPath);
+    }
+    const relTargets = resolveResetTargets(paths, opts, index);
+    if (!relTargets.length) {
+        // eslint-disable-next-line no-console
+        console.warn('Nothing to unstage (specify paths or --all)');
+        return;
+    }
+    const removed = [];
+    const keep = {};
+    for (const [rel, meta] of Object.entries(index)) {
+        if (matchesTarget(rel, relTargets)) {
+            removed.push(rel);
+            continue;
+        }
+        keep[rel] = meta;
+    }
+    await (0, fs_1.writeIndex)(indexPath, keep);
+    if (removed.length === 0) {
+        // eslint-disable-next-line no-console
+        console.warn('No matching paths were staged.');
+    }
+    else {
+        removed.forEach((rel) => console.log(ui_1.colors.green(`unstaged ${rel}`)));
+    }
+}
+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.');
+    }
+}
+function sameMeta(a, b) {
+    return a.hash === b.hash && a.size === b.size && a.mode === b.mode;
+}
+function resolveAddTargets(paths, opts) {
+    if ((opts?.all || !paths?.length) && !paths.includes('.')) {
+        return ['.'];
+    }
+    return paths;
+}
+function resolveResetTargets(paths, opts, index) {
+    if (opts?.all)
+        return Object.keys(index);
+    if (!paths?.length)
+        return [];
+    return paths.map((p) => {
+        const abs = path_1.default.isAbsolute(p) ? p : path_1.default.join(process.cwd(), p);
+        return (0, fs_1.pathToPosix)(path_1.default.relative(process.cwd(), abs)) || '.';
+    });
+}
+async function restoreWorktree(paths, index, witPath) {
+    if (!paths?.length) {
+        // eslint-disable-next-line no-console
+        console.warn('Specify paths to restore (worktree).');
+        return;
+    }
+    const targets = expandTargets(paths, index);
+    if (!targets.length) {
+        // eslint-disable-next-line no-console
+        console.warn('No matching tracked paths to restore.');
+        return;
+    }
+    for (const rel of targets) {
+        const meta = index[rel];
+        const buf = await (0, fs_1.readBlob)(witPath, meta.hash);
+        if (!buf) {
+            // eslint-disable-next-line no-console
+            console.warn(`Missing blob for ${rel}, cannot restore.`);
+            continue;
+        }
+        const abs = path_1.default.join(process.cwd(), rel);
+        await (0, fs_1.ensureDirForFile)(abs);
+        await promises_1.default.writeFile(abs, buf);
+        const perm = parseInt(meta.mode, 8) & 0o777;
+        await promises_1.default.chmod(abs, perm);
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.green(`restored ${rel}`));
+    }
+}
+function expandTargets(inputs, index) {
+    const result = new Set();
+    const targets = inputs.map((p) => {
+        const abs = path_1.default.isAbsolute(p) ? p : path_1.default.join(process.cwd(), p);
+        return (0, fs_1.pathToPosix)(path_1.default.relative(process.cwd(), abs)) || '.';
+    });
+    if (!targets.length)
+        return [];
+    for (const rel of Object.keys(index)) {
+        if (targets.some((t) => t === '.' || rel === t || rel.startsWith(`${t}/`))) {
+            result.add(rel);
+        }
+    }
+    return Array.from(result).sort();
+}
+async function collectTargets(inputs) {
+    const targets = [];
+    for (const input of inputs) {
+        const abs = path_1.default.isAbsolute(input) ? input : path_1.default.join(process.cwd(), input);
+        const stat = await promises_1.default.stat(abs);
+        const rel = (0, fs_1.pathToPosix)(path_1.default.relative(process.cwd(), abs)) || '.';
+        targets.push({ abs, rel, isDir: stat.isDirectory() });
+    }
+    return targets;
+}
+function isWithinTargets(rel, targets) {
+    if (!targets.size)
+        return false;
+    if (targets.has('.'))
+        return true;
+    for (const t of targets) {
+        if (rel === t || rel.startsWith(`${t}/`))
+            return true;
+    }
+    return false;
+}
+function matchesTarget(rel, targets) {
+    if (!targets.length)
+        return false;
+    if (targets.includes('.'))
+        return true;
+    return targets.some((t) => rel === t || rel.startsWith(`${t}/`));
+}
+async function computeMetaWithCache(file, rel, index) {
+    const stat = await promises_1.default.stat(file);
+    const mode = (0, fs_1.modeToString)(stat.mode);
+    const mtime = (0, fs_1.mtimeSec)(stat);
+    const indexed = index[rel];
+    if (indexed && indexed.size === stat.size && indexed.mode === mode && indexed.mtime === mtime) {
+        return indexed;
+    }
+    return (0, fs_1.computeFileMeta)(file);
+}
+function printStatus(sections) {
+    const { untracked, modified, deleted } = sections;
+    if (!untracked.length && !modified.length && !deleted.length) {
+        // eslint-disable-next-line no-console
+        console.log('Nothing to commit, working tree clean.');
+        return;
+    }
+    if (modified.length) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.modified('Modified:'));
+        modified.forEach((f) => console.log(ui_1.colors.modified(`  ${f}`)));
+    }
+    if (deleted.length) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.deleted('Deleted:'));
+        deleted.forEach((f) => console.log(ui_1.colors.deleted(`  ${f}`)));
+    }
+    if (untracked.length) {
+        // eslint-disable-next-line no-console
+        console.log(ui_1.colors.untracked('Untracked:'));
+        untracked.forEach((f) => console.log(ui_1.colors.untracked(`  ${f}`)));
+    }
+}

package/dist/index.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const commander_1 = require("commander");
+const registerCommands_1 = require("./commands/registerCommands");
+const package_json_1 = __importDefault(require("../package.json"));
+// Polyfill for toReversed (Node < 20)
+if (!Array.prototype.toReversed) {
+    // eslint-disable-next-line no-extend-native
+    Array.prototype.toReversed = function () {
+        return [...this].reverse();
+    };
+}
+const VERSION = package_json_1.default.version || '0.0.0';
+async function run(argv = process.argv) {
+    const program = new commander_1.Command();
+    program
+        .name('wit')
+        .description('wit CLI: single-branch, verifiable, optionally encrypted repo tool backed by Walrus + Sui')
+        .version(VERSION);
+    (0, registerCommands_1.registerCommands)(program);
+    const normalized = normalizeArgs(argv.slice());
+    await program.parseAsync(normalized);
+}
+if (require.main === module) {
+    run().catch((err) => {
+        // eslint-disable-next-line no-console
+        console.error(err);
+        process.exitCode = 1;
+    });
+}
+function normalizeArgs(argv) {
+    const args = [...argv];
+    const idx = args.findIndex((a) => a === 'checkout');
+    if (idx > -1 && args.length > idx + 1) {
+        const next = args[idx + 1];
+        if (next && next.startsWith('-') && next !== '--') {
+            args.splice(idx + 1, 0, '--');
+        }
+    }
+    return args;
+}

package/dist/lib/config.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_NETWORK = exports.DEFAULT_RELAYS = void 0;
+exports.readGlobalConfig = readGlobalConfig;
+exports.readRepoConfig = readRepoConfig;
+exports.buildWalrusClientOptions = buildWalrusClientOptions;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+exports.DEFAULT_RELAYS = ['https://relay.walrus-testnet.mystenlabs.com'];
+exports.DEFAULT_NETWORK = 'testnet';
+async function readGlobalConfig() {
+    const home = process.env.HOME;
+    if (!home)
+        return {};
+    const file = path_1.default.join(home, '.witconfig');
+    try {
+        const raw = await promises_1.default.readFile(file, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT')
+            return {};
+        // eslint-disable-next-line no-console
+        console.warn(`Warning: could not read ${file}: ${err.message}`);
+        return {};
+    }
+}
+async function readRepoConfig(witDir) {
+    const file = path_1.default.join(witDir, 'config.json');
+    const raw = await promises_1.default.readFile(file, 'utf8');
+    return JSON.parse(raw);
+}
+function buildWalrusClientOptions(repoCfg, globalCfg) {
+    const relays = cleanRelays(repoCfg.relays?.length ? repoCfg.relays : globalCfg.relays) || exports.DEFAULT_RELAYS;
+    return {
+        network: repoCfg.network || globalCfg.network || exports.DEFAULT_NETWORK,
+        relays,
+        repo_id: repoCfg.repo_id,
+    };
+}
+function cleanRelays(relays) {
+    if (!relays || !relays.length)
+        return null;
+    const trimmed = relays.map((r) => r.trim()).filter(Boolean);
+    return trimmed.length ? trimmed : null;
+}

package/dist/lib/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TESTNET_SUI_RPC = exports.WIT_MODULE_NAME = exports.WIT_PACKAGE_ID = void 0;
+exports.WIT_PACKAGE_ID = '0x8c91d82b2292ac53a4fa5b21de86b1073230ac1d17dd6ae336ab5b559c329e09';
+exports.WIT_MODULE_NAME = 'repository';
+exports.TESTNET_SUI_RPC = 'https://fullnode.testnet.sui.io:443';

package/dist/lib/fs.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathToPosix = pathToPosix;
+exports.modeToString = modeToString;
+exports.mtimeSec = mtimeSec;
+exports.computeFileMeta = computeFileMeta;
+exports.readIndex = readIndex;
+exports.writeIndex = writeIndex;
+exports.blobFileName = blobFileName;
+exports.ensureBlobFromFile = ensureBlobFromFile;
+exports.readBlob = readBlob;
+exports.ensureDirForFile = ensureDirForFile;
+exports.removeFileIfExists = removeFileIfExists;
+exports.buildIgnore = buildIgnore;
+exports.shouldIgnore = shouldIgnore;
+exports.walkFiles = walkFiles;
+const crypto_1 = __importDefault(require("crypto"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const ignore_1 = __importDefault(require("ignore"));
+const HASH_PREFIX = 'sha256-';
+const DEFAULT_IGNORE_PATTERNS = ['.git', '.wit', 'node_modules'];
+const BLOB_DIR = 'objects/blobs';
+function pathToPosix(p) {
+    return p.split(path_1.default.sep).join('/');
+}
+function modeToString(mode) {
+    const isExec = (mode & 0o111) !== 0;
+    return `100${isExec ? '755' : '644'}`;
+}
+function mtimeSec(stat) {
+    return Math.floor(stat.mtimeMs / 1000);
+}
+async function computeFileMeta(filePath) {
+    const stat = await promises_1.default.stat(filePath);
+    const data = await promises_1.default.readFile(filePath);
+    const hash = HASH_PREFIX + crypto_1.default.createHash('sha256').update(data).digest('base64');
+    return {
+        hash,
+        size: stat.size,
+        mode: modeToString(stat.mode),
+        mtime: mtimeSec(stat),
+    };
+}
+async function readIndex(indexPath) {
+    try {
+        const raw = await promises_1.default.readFile(indexPath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT')
+            return {};
+        throw err;
+    }
+}
+async function writeIndex(indexPath, index) {
+    const serialized = JSON.stringify(index, null, 2) + '\n';
+    await promises_1.default.writeFile(indexPath, serialized, 'utf8');
+}
+function blobFileName(hash) {
+    return hash.replace(/\//g, '_').replace(/\+/g, '-');
+}
+async function ensureBlobFromFile(witPath, hash, filePath) {
+    const blobPath = path_1.default.join(witPath, BLOB_DIR, blobFileName(hash));
+    try {
+        await promises_1.default.access(blobPath);
+        return;
+    }
+    catch (err) {
+        if (err?.code !== 'ENOENT')
+            throw err;
+    }
+    await promises_1.default.mkdir(path_1.default.dirname(blobPath), { recursive: true });
+    const data = await promises_1.default.readFile(filePath);
+    await promises_1.default.writeFile(blobPath, data);
+}
+async function readBlob(witPath, hash) {
+    const blobPath = path_1.default.join(witPath, BLOB_DIR, blobFileName(hash));
+    try {
+        return await promises_1.default.readFile(blobPath);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+async function ensureDirForFile(filePath) {
+    await promises_1.default.mkdir(path_1.default.dirname(filePath), { recursive: true });
+}
+async function removeFileIfExists(filePath) {
+    try {
+        await promises_1.default.unlink(filePath);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT')
+            return;
+        throw err;
+    }
+}
+async function buildIgnore(root, extraPatterns = []) {
+    const ig = (0, ignore_1.default)();
+    ig.add(DEFAULT_IGNORE_PATTERNS);
+    ig.add(extraPatterns);
+    for (const file of ['.gitignore', '.witignore']) {
+        try {
+            const raw = await promises_1.default.readFile(path_1.default.join(root, file), 'utf8');
+            ig.add(raw);
+        }
+        catch (err) {
+            if (err?.code !== 'ENOENT')
+                throw err;
+        }
+    }
+    return ig;
+}
+function shouldIgnore(ig, relPosix, isDir) {
+    if (relPosix === '' || relPosix === '.')
+        return false;
+    const target = isDir ? (relPosix.endsWith('/') ? relPosix : `${relPosix}/`) : relPosix;
+    return ig.ignores(target);
+}
+async function walkFiles(root, ig, baseDir = root, tracked) {
+    const trackedList = tracked ? Array.from(tracked) : null;
+    async function walkDir(dir) {
+        const entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+        const files = [];
+        const dirTasks = [];
+        for (const entry of entries) {
+            const full = path_1.default.join(dir, entry.name);
+            const rel = path_1.default.relative(baseDir, full);
+            const relPosix = pathToPosix(rel);
+            const isDir = entry.isDirectory();
+            const hasTrackedDesc = trackedList && isDir ? trackedList.some((p) => p === relPosix || p.startsWith(`${relPosix}/`)) : false;
+            if (shouldIgnore(ig, relPosix, isDir) && !(tracked?.has(relPosix) || hasTrackedDesc))
+                continue;
+            if (isDir) {
+                dirTasks.push(walkDir(full));
+            }
+            else if (entry.isFile()) {
+                files.push(full);
+            }
+        }
+        if (dirTasks.length) {
+            const nested = await Promise.all(dirTasks);
+            nested.forEach((list) => files.push(...list));
+        }
+        return files;
+    }
+    return walkDir(root);
+}