//! `zit import-fossil` — bring a fossil repository's history into zit, with
//! the compatibility consequence CHOSEN AT IMPORT TIME (#61). Two modes, no
//! default: the difference is permanent and the operator must pick.
//!
//! --compatible The artifact corpus is preserved verbatim: same hashes,
//! same project code, flat manifests. The result stays a
//! first-class member of the origin's sync world. This is
//! the clone machinery wearing its import name — fossil's
//! sync protocol IS the import path; no SQLite is read.
//! (Dispatched in main.zig straight onto the clone runner.)
//!
//! --submanifest REBIRTH: every check-in re-mints as a sub-manifest tree
//! under a NEW project code — uniform S-tree history from
//! the first commit, and a permanent break with the origin
//! (never syncs with it again; signatures cannot survive
//! rehashing and are stripped and counted).
//!
//! This file owns the submanifest arm: the #41 evidence gate first — replay
//! the WHOLE history through the real tree builder, print the costs, and
//! REFUSE a conversion the evidence says would be worse than flat unless
//! --force — then the conversion itself. The staged-publication discipline
//! comes from `publication.zig` (the #61 step-1 extraction).
const std = @import("std");
const zit = @import("zit");
const cli = zit.cli;
const artifact = zit.artifact;
const Repository = zit.Repository;
const convert = @import("fossil_convert.zig");
const cmd_sync = @import("../cmd/sync.zig");
pub const Mode = enum { compatible, submanifest };
/// The submanifest arm: SOURCE is a local store (a directory holding `.zit`
/// or the `.zit` file itself) already populated by `zit clone` from the
/// fossil origin. The gate runs unconditionally; the conversion runs only
/// when the gate passes (or --force overrides its refusal).
pub fn runSubmanifestImport(
gpa: std.mem.Allocator,
io: std.Io,
arena: std.mem.Allocator,
source: []const u8,
destination: []const u8,
k_override: ?u8,
verb: []const u8,
streams: cli.Streams,
) cli.Exit {
const cwd = std.Io.Dir.cwd();
// A sync URL is the fossil itself (zit#168): clone it into a transient
// sibling of DIR, convert from that, and remove it whether or not the
// conversion publishes. The flat intermediate never needs a name.
var flat_source = source;
var transient: ?[]const u8 = null;
defer if (transient) |t| cwd.deleteTree(io, t) catch {};
if (std.mem.startsWith(u8, source, "http://") or std.mem.startsWith(u8, source, "https://")) {
const t = std.fmt.allocPrint(arena, "{s}.zit-tmp-flat", .{destination}) catch return oom(streams);
cwd.deleteTree(io, t) catch {}; // a prior run's wreckage, if any
streams.out.print("{s}: cloning the fossil into a transient flat store first\n", .{verb}) catch {};
if (cmd_sync.runClone(gpa, io, arena, &.{ source, t }, streams) != .ok) {
cwd.deleteTree(io, t) catch {};
streams.err.print("zit {s}: the clone of '{s}' did not complete; nothing was converted\n", .{ verb, source }) catch {};
return .failure;
}
transient = t;
flat_source = t;
}
const root = (cli.resolveRoot(arena, io, flat_source) catch return oom(streams)) orelse {
streams.err.print("zit {s}: '{s}' is neither a sync URL nor a zit repository\n", .{ verb, flat_source }) catch {};
return .failure;
};
var root_dir = root.dir;
defer root_dir.close(io);
var repo: Repository = undefined;
Repository.open(&repo, gpa, io, root_dir, .{}) catch {
streams.err.print("zit {s}: cannot read the source repository\n", .{verb}) catch {};
return .failure;
};
defer repo.deinit(gpa);
var clock = convert.Phase.start(io, streams);
const k = pickK(gpa, &repo, k_override, verb, streams) orelse return .failure;
clock.done("k sweep");
const phantoms = convert.phantomCount(gpa, &repo) catch {
streams.err.print("zit {s}: walking the source corpus failed\n", .{verb}) catch {};
return .failure;
};
if (phantoms != 0) {
streams.err.print("zit {s}: the source holds phantoms — an incomplete corpus cannot re-mint; pull to convergence first\n", .{verb}) catch {};
return .failure;
}
const source_bytes = storeBytes(io, root_dir);
return runConversion(gpa, io, &repo, destination, k, source_bytes, verb, streams);
}
/// The conversion itself, under the staged-publication discipline (#61):
/// everything is written into a nonce-named staging directory beside the
/// destination, the stage machine orders write -> freeze -> verify, and the
/// atomic rename is the ONLY commit point -- a crash at any earlier moment
/// leaves a sweepable `.zit-tmp-*` and an untouched destination. This
/// converter writes its store directly as the published generation (its
/// output is born packed-enough; `zit pack` owns later compaction), so the
/// raw-generation stages pass through empty and the idempotent discard is
/// a no-op.
fn runConversion(
gpa: std.mem.Allocator,
io: std.Io,
repo: *Repository,
destination: []const u8,
k: u4,
source_bytes: ?u64,
verb: []const u8,
streams: cli.Streams,
) cli.Exit {
const cwd = std.Io.Dir.cwd();
var bundle = zit.publication.PublicationBundle.create(gpa, io, cwd, destination) catch {
streams.err.print("zit {s}: cannot stage beside '{s}'\n", .{ verb, destination }) catch {};
return .failure;
};
var live = true;
defer if (live) bundle.abort();
bundle.advance(.raw_frozen) catch return convFail(streams, verb);
bundle.advance(.packing) catch return convFail(streams, verb);
var file = bundle.createPackedGeneration() catch return convFail(streams, verb);
defer file.close(io);
const hash_kind: u8 = @intFromEnum(zit.artifact.HashPolicy.sha3);
var fs = zit.storage.FileStorage.init(io, file, 0);
var dest = zit.logstore.LogStore.open(gpa, fs.storageFile(), hash_kind) catch return convFail(streams, verb);
defer dest.deinit(gpa);
// The NEW project code -- the non-negotiable identity break (#61):
// derived from the destination path plus the mode marker, so the result
// can never be mistaken for (or synced with) the origin.
const project_code = zit.sync.deriveProjectCode(&.{ destination, "import-fossil-submanifest" });
dest.putConfig(.{
.hash_policy = hash_kind,
.default_branch = "trunk",
.project_id = "",
.project_code = &project_code,
.enable_submanifests = true,
.submanifest_k = k,
.seen_submanifest = true,
}) catch return convFail(streams, verb);
const result = convert.remint(gpa, io, repo, &dest, k, &project_code, verb, streams) catch |e| {
switch (e) {
error.Diverged => {}, // already reported with the path
error.BrokenAncestry => streams.err.print("zit {s}: the source corpus has holes; pull to convergence first\n", .{verb}) catch {},
error.OutOfMemory => streams.err.print("zit {s}: out of memory\n", .{verb}) catch {},
error.Storage, error.Corrupt => streams.err.print("zit {s}: reading the source failed\n", .{verb}) catch {},
}
return .failure;
};
// Count reconciliation against the source store: re-minted + carried +
// dropped must account for every source artifact (the phantom pre-scan
// found none), or the conversion lost something silently.
const accounted = result.checkins + result.blobs + result.carried +
result.controls_remapped + result.clusters_dropped;
if (accounted != result.census.total) {
streams.err.print(
"zit {s}: accounting mismatch — {d} artifacts in, {d} accounted; nothing published\n",
.{ verb, result.census.total, accounted },
) catch {};
return .failure;
}
dest.commit() catch return convFail(streams, verb);
bundle.advance(.packed_frozen) catch return convFail(streams, verb);
// The pair-by-pair differential proof ran inside `remint`, reading back
// through the same store API every verb uses; the stage records it.
bundle.advance(.verified) catch return convFail(streams, verb);
bundle.discardRawGeneration() catch return convFail(streams, verb); // raw-less: a no-op by idempotence
zit.checkout.write(io, bundle.temporary, .{ .version = "", .branch = "trunk", .merge_parent = "", .special_op = "", .manifest_flags = "" }) catch return convFail(streams, verb);
bundle.verifyStagingManifest() catch return convFail(streams, verb);
bundle.publish(destination, .{}) catch {
streams.err.print("zit {s}: publishing '{s}' failed (it may already exist)\n", .{ verb, destination }) catch {};
return .failure;
};
live = false;
bundle.abort(); // post-publish: releases handles; the rename already landed
streams.out.print(
"converted: {d} check-ins re-minted as sub-manifest trees (k={d}), {d} blobs and" ++
" {d} artifacts carried verbatim, {d} control artifact(s) remapped, {d} cluster(s)" ++
" dropped, {d} signature(s) stripped, {d} provenance note(s) minted; every pair" ++
" verified file-set-equivalent\n" ++
"the result is a NEW project: it cannot sync with the origin. open it with" ++
" 'zit open' inside '{s}'\n",
.{ result.checkins, k, result.blobs, result.carried, result.controls_remapped, result.clusters_dropped, result.signatures_stripped, result.provenance_notes, destination },
) catch {};
// The evidence a conversion decision wants is the result itself (#129):
// the flat store's bytes against the converted store's, measured, not
// modelled — with the reminder that pack is what makes the second number
// final.
var published = cwd.openDir(io, destination, .{}) catch return .ok;
defer published.close(io);
const converted_bytes = storeBytes(io, published);
if (source_bytes != null and converted_bytes != null) {
streams.out.print(
"store: flat source {d} bytes, converted {d} bytes (delta-encoded as written against the source's own chains)\nnext: run 'zit pack' in '{s}' — it finds better bases and usually shrinks the store several-fold\n",
.{ source_bytes.?, converted_bytes.?, destination },
) catch {};
} else {
streams.out.print("the store is delta-encoded as written against the source's own chains\nnext: run 'zit pack' in '{s}' — it finds better bases and usually shrinks the store several-fold\n", .{destination}) catch {};
}
return .ok;
}
fn convFail(streams: cli.Streams, verb: []const u8) cli.Exit {
streams.err.print("zit {s}: the conversion could not complete; nothing was published\n", .{verb}) catch {};
return .failure;
}
/// Bytes of the `.zit` store under `dir`, or null when it cannot be read.
fn storeBytes(io: std.Io, dir: std.Io.Dir) ?u64 {
const st = dir.statFile(io, zit.repo_filename, .{}) catch return null;
return st.size;
}
/// Name the partition parameter: the operator's --k, else the static §6.3
/// sweep over the source tip's name set. There is no whole-history replay
/// gate any more (#129, #167): the conversion writes a NEW project beside an
/// untouched source, so the honest evidence is the converted store itself,
/// reported by the summary — not a model of it that cost as much to run as
/// the conversion. `zit submanifest analyze --replay-all` remains for anyone
/// who wants the replay before spending the machine time. Null = refused
/// (already diagnosed).
fn pickK(
gpa: std.mem.Allocator,
repo: *Repository,
k_override: ?u8,
verb: []const u8,
streams: cli.Streams,
) ?u4 {
if (k_override) |kk| {
if (kk < artifact.min_k or kk > artifact.max_k) {
streams.err.print("zit {s}: --k wants 1..12 (got {d})\n", .{ verb, kk }) catch {};
return null;
}
streams.out.print("k={d} pinned by --k\n", .{kk}) catch {};
return @intCast(kk);
}
const tip = repo.resolve("tip", .checkin) catch {
streams.err.print("zit {s}: the source repository has no check-in to measure\n", .{verb}) catch {};
return null;
};
var fl = (repo.files(gpa, tip) catch null) orelse {
streams.err.print("zit {s}: cannot read the source tip check-in\n", .{verb}) catch {};
return null;
};
defer fl.deinit(gpa);
var arena_state = std.heap.ArenaAllocator.init(gpa);
defer arena_state.deinit();
const aa = arena_state.allocator();
var entries: std.ArrayList(artifact.FCard) = .empty;
var it = fl.iterator();
while (it.next()) |f| {
entries.append(aa, .{
.filename = aa.dupe(u8, f.filename) catch return null,
.hash = if (f.hash) |h| aa.dupe(u8, h) catch return null else null,
.perm = if (f.perm) |p| aa.dupe(u8, p) catch return null else null,
.old_name = null,
.mode = f.mode,
}) catch return null;
}
if (entries.items.len == 0) {
streams.err.print("zit {s}: the source tip has no files to measure\n", .{verb}) catch {};
return null;
}
// The measurement algo follows the source identity space: 40-hex = SHA-1.
const algo: artifact.HashAlgo = if (repo.hashOf(tip).len == 40) .sha1 else .sha3_256;
var costs: [artifact.max_k - artifact.min_k + 1]zit.submanifest.Cost = undefined;
var n: usize = 0;
var k: u8 = artifact.min_k;
while (k <= artifact.max_k) : (k += 1) {
costs[n] = zit.submanifest.cost(gpa, entries.items, @intCast(k), algo) catch return null;
n += 1;
}
const w = zit.submanifest.best(costs[0..n]) orelse {
// Every k leaves this name set flat (§6.2 step 2): the same refusal
// `zit submanifest enable` makes, for the same reason — nothing here
// would become a tree, and inventing a k is not the converter's call.
streams.err.print(
"zit {s}: no k partitions the source tip's {d} names into a tree (§6.2 step 2),\n" ++
"so there is nothing to convert into sub-manifests; pin one with --k N if you\n" ++
"want the rebirth anyway, or import with --compatible instead.\n",
.{ verb, entries.items.len },
) catch {};
return null;
};
streams.out.print("k={d} minimizes the §6.3 objective over the source tip's {d} names\n", .{ w.k, entries.items.len }) catch {};
return w.k;
}
fn oom(streams: cli.Streams) cli.Exit {
streams.err.writeAll("zit: out of memory\n") catch {};
return .failure;
}