[UX] resolve --dry-run output full dependency graph as a plan, consumable by unpack

Open
#9 0 comments 0 reactions 0 assignees View on GitHub

Nobody has claimed this yet.

Assessment

Difficulty
5/5
Estimated time
Over a week
Newbie friendliness
8/100
Issue type
Feature
Clarity
Needs clarification
Activity status
Active
Tech stack
go
Domain
cli, devtools

Research direction

The issue asks for --dry-run to print the full resolved dependency graph as a plan that unpack can consume, with a lockfile as the shared artifact. Read the resolve, unpack and dry-run paths first to see how they currently duplicate fetch and verify logic. The open questions on metadata-only lookup, conflicting pins and removal previews need maintainer decisions before any code. Work should not start until those are settled.

Written by the indexing model from the issue text.

Description

Summary 🤖

grcli should behave like a typical package manager for Gemara artifact dependencies: resolve → lock → sync. Given a root artifact, compute its full transitive dependency graph, record what was found as a durable lockfile, then make a local directory match that lockfile exactly -- fetch what's missing, verify it, and remove what's no longer needed. Fetching/verifying/writing should be one reusable operation driven entirely by a lockfile -- not something resolve and unpack each implement separately.

The lockfile should also work disconnected from the network: a fully offline directory (or archive) plus its lockfile should be independently re-verifiable by anyone, with no need to trust whoever produced it.

Why

A caller should be able to see the full resolved dependency set — every version, every conflict, every license — before any content is fetched. That preview becomes the input to the fetch/sync step, so the expensive graph-walk only ever has to happen once per resolution. It also gives a natural hook for auditing (license compatibility across the whole graph) before committing to anything, and gives downstream tooling (policy engines, offline/airgapped consumers) a stable, inspectable artifact to build on instead of having to re-derive it.

This covers some of the authoring flows for compliance-as-code: reading a single artifact, and syncing a project's full dependency set to disk. grcli's responsibility ends at producing a correct, verified, synced tree plus its lockfile. Aggregation or derived artifacts can be part of consumer workflow.

Open Questions

  • Can the full resolved graph (versions, digests, licenses) be known without fetching full artifact content, or does that require a cheaper metadata-only lookup per dependency?
  • When the resolved graph disagrees with itself (same dependency pinned to two different versions), should the fetch/sync step refuse to proceed, or proceed and surface the disagreement for something downstream to handle?
  • When syncing a local directory to match a lockfile, should content no longer referenced by the lockfile be removed automatically, and if so, how does a caller preview that removal before it happens?
  • Should re-verifying an already-fetched, offline dependency set require any network access at all, or must it be fully self-contained?
Dominant language
Go
Stars
0
Forks
2
Avg merge
1d 15h
Merged PRs (30d)
6

Getting set up

First steps

  1. Read the whole issue, then the project's contributing guide.
  2. Comment on the issue to say you are picking it up — it saves two people doing the same work.
  3. Fork the repository and make your change on a branch.
  4. Open a pull request that references the issue number.

More from gemaraproj/grcli

All issues in gemaraproj/grcli

Similar issues

More Go issues

Get new issues in your inbox

A short digest of beginner-friendly GitHub issues.