+331

.tack/default.nix

Reviewed

··· 1 1 + # SPDX-License-Identifier: EUPL-1.2 2 2 + # tack-managed resolver. delete this line to take ownership; tack will leave it alone afterwards. 3 3 + 4 4 + let 5 5 + inherit (builtins) 6 6 + attrNames 7 7 + attrValues 8 8 + concatMap 9 9 + elem 10 10 + elemAt 11 11 + filter 12 12 + foldl' 13 13 + fromJSON 14 14 + head 15 15 + intersectAttrs 16 16 + isList 17 17 + isString 18 18 + listToAttrs 19 19 + mapAttrs 20 20 + match 21 21 + pathExists 22 22 + readFile 23 23 + substring 24 24 + tail 25 25 + trace 26 26 + ; 27 27 + 28 28 + call = 29 29 + { 30 30 + overrides ? { }, 31 31 + }: 32 32 + let 33 33 + pins = fromTOML (readFile ./pins.toml); 34 34 + lock = fromJSON (readFile ./pins.lock.json); 35 35 + all_follow_raw = pins.all_follow or { }; 36 36 + 37 37 + # flatten `target = [aliases]` rows alongside `alias = "target"` rows 38 38 + all_follow = foldl' ( 39 39 + acc: key: 40 40 + let 41 41 + val = all_follow_raw.${key}; 42 42 + in 43 43 + if isList val then 44 44 + acc 45 45 + // { 46 46 + ${key} = key; 47 47 + } 48 48 + // listToAttrs ( 49 49 + map (a: { 50 50 + name = a; 51 51 + value = key; 52 52 + }) val 53 53 + ) 54 54 + else if isString val then 55 55 + acc // { ${key} = val; } 56 56 + else 57 57 + acc 58 58 + ) { } (attrNames all_follow_raw); 59 59 + 60 60 + knownTypes = [ 61 61 + "github" 62 62 + "gitlab" 63 63 + "git" 64 64 + "tarball" 65 65 + "path" 66 66 + "indirect" 67 67 + ]; 68 68 + 69 69 + # path nodes are convenience pins, so return the live local path directly 70 70 + # because fetchTree rejects unlocked paths in pure eval 71 71 + fetchPin = 72 72 + name: 73 73 + if !(lock ? ${name}) then 74 74 + throw "tack: pin '${name}' has no lock entry; run tack update" 75 75 + else 76 76 + let 77 77 + node = lock.${name}; 78 78 + in 79 79 + if (node.type or "") == "path" then 80 80 + { 81 81 + outPath = if substring 0 1 node.path == "/" then node.path else ./. + ("/" + node.path); 82 82 + lastModified = node.lastModified or 0; 83 83 + } 84 84 + // (if node ? narHash then { inherit (node) narHash; } else { }) 85 85 + else if !(elem (node.type or "") knownTypes) then 86 86 + throw "tack: unknown lock type '${node.type or "?"}' for pin '${name}'" 87 87 + else 88 88 + fetchTree node; 89 89 + 90 90 + fetchFixed = 91 91 + name: entry: 92 92 + let 93 93 + raw = derivation { 94 94 + inherit name; 95 95 + inherit (entry) url; 96 96 + builder = "builtin:fetchurl"; 97 97 + system = "builtin"; 98 98 + outputHash = entry.sha256; 99 99 + outputHashAlgo = "sha256"; 100 100 + outputHashMode = "flat"; 101 101 + }; 102 102 + unpacked = derivation { 103 103 + inherit name; 104 104 + builder = "builtin:unpack-channel"; 105 105 + system = "builtin"; 106 106 + src = raw; 107 107 + channelName = name; 108 108 + }; 109 109 + in 110 110 + if (entry.unpack or "file") == "tarball" then unpacked.outPath + "/" + name else raw.outPath; 111 111 + 112 112 + resolveSpec = upLock: spec: if isList spec then walkPath upLock upLock.root spec else spec; 113 113 + 114 114 + walkPath = 115 115 + upLock: nodeName: path: 116 116 + if path == [ ] then 117 117 + nodeName 118 118 + else if !(upLock.nodes ? ${nodeName}) then 119 119 + throw "tack: follows path dead-end: no node '${nodeName}' in flake.lock" 120 120 + else 121 121 + let 122 122 + key = head path; 123 123 + inputs = upLock.nodes.${nodeName}.inputs or { }; 124 124 + in 125 125 + if !(inputs ? ${key}) then 126 126 + throw "tack: follows path dead-end: node '${nodeName}' has no input '${key}'" 127 127 + else 128 128 + walkPath upLock (resolveSpec upLock inputs.${key}) (tail path); 129 129 + 130 130 + followsFor = 131 131 + pin: 132 132 + let 133 133 + rules = removeAttrs all_follow (pin.exclude_follow or [ ]); 134 134 + in 135 135 + { 136 136 + level = rules // (pin.follows or { }); 137 137 + deep = rules; 138 138 + }; 139 139 + 140 140 + resolveFollows = mapAttrs ( 141 141 + _: target: self.${target} or (throw "tack: follows target '${target}' is not a pin") 142 142 + ); 143 143 + 144 144 + # follows key is `flake:name`, `tack:name`, or bare `name` 145 145 + # project onto one side, rekeyed to bare names 146 146 + followsForSide = 147 147 + side: follows: 148 148 + listToAttrs ( 149 149 + concatMap ( 150 150 + key: 151 151 + let 152 152 + m = match "(flake|tack):(.*)" key; 153 153 + in 154 154 + if m == null then 155 155 + [ 156 156 + { 157 157 + name = key; 158 158 + value = follows.${key}; 159 159 + } 160 160 + ] 161 161 + else if head m == side then 162 162 + [ 163 163 + { 164 164 + name = elemAt m 1; 165 165 + value = follows.${key}; 166 166 + } 167 167 + ] 168 168 + else 169 169 + [ ] 170 170 + ) (attrNames follows) 171 171 + ); 172 172 + 173 173 + mkCallerInputs = 174 174 + upLock: nodeName: rawInputs: levelFollows: deepFollows: 175 175 + let 176 176 + resolved = resolveFollows levelFollows; 177 177 + in 178 178 + mapAttrs ( 179 179 + n: _decl: 180 180 + resolved.${n} or ( 181 181 + if upLock != null then 182 182 + let 183 183 + ref = 184 184 + (upLock.nodes.${nodeName}.inputs or { }).${n} 185 185 + or (throw "tack: input '${n}' declared but not in flake.lock node '${nodeName}'"); 186 186 + childName = resolveSpec upLock ref; 187 187 + childNode = upLock.nodes.${childName}; 188 188 + childSrc = fetchTree childNode.locked; 189 189 + in 190 190 + if childNode.flake or true then evalTransitive upLock childName childSrc deepFollows else childSrc 191 191 + else 192 192 + throw "tack: no flake.lock; cannot resolve input '${n}'" 193 193 + ) 194 194 + ) rawInputs; 195 195 + 196 196 + mkFlakeResult = 197 197 + sourceInfo: flakeDir: callerInputs: outputs: 198 198 + outputs 199 199 + // sourceInfo 200 200 + // { 201 201 + outPath = flakeDir; 202 202 + inputs = callerInputs; 203 203 + inherit outputs sourceInfo; 204 204 + _type = "flake"; 205 205 + }; 206 206 + 207 207 + evalFlake = 208 208 + sourceInfo: flakeDir: upLock: nodeName: levelFollows: deepFollows: 209 209 + let 210 210 + raw = import (flakeDir + "/flake.nix"); 211 211 + 212 212 + tackPinsPath = flakeDir + "/.tack/pins.toml"; 213 213 + hasTack = pathExists tackPinsPath; 214 214 + upPins = if hasTack then fromTOML (readFile tackPinsPath) else { }; 215 215 + 216 216 + # project follows onto each side, keep only names that side has 217 217 + # bare follow reaches both; `flake:`/`tack:` reaches just one 218 218 + tackOverrides = resolveFollows ( 219 219 + intersectAttrs (upPins.inputs or { }) (followsForSide "tack" levelFollows) 220 220 + ); 221 221 + flakeLevel = intersectAttrs (raw.inputs or { }) (followsForSide "flake" levelFollows); 222 222 + 223 223 + # deep follows pass down raw, so each descendant re-projects per side 224 224 + callerInputs = mkCallerInputs upLock nodeName (raw.inputs or { }) flakeLevel deepFollows; 225 225 + 226 226 + # upstream declares its outputs forward tackOverrides; a closed `{ self }:` 227 227 + # would throw on the extra kwarg, so forward only when declared 228 228 + supportsOverrides = (upPins.tack or { }).recomposable or false; 229 229 + 230 230 + extraArgs = if supportsOverrides && tackOverrides != { } then { inherit tackOverrides; } else { }; 231 231 + 232 232 + outputs = raw.outputs (callerInputs // extraArgs // { self = result; }); 233 233 + 234 234 + result = 235 235 + let 236 236 + base = mkFlakeResult sourceInfo flakeDir callerInputs outputs; 237 237 + in 238 238 + if hasTack && tackOverrides != { } && !supportsOverrides then 239 239 + trace "tack: ${flakeDir}: not marked recomposable (set [tack] recomposable = true); overrides will not reach upstream" base 240 240 + else 241 241 + base; 242 242 + in 243 243 + result; 244 244 + 245 245 + evalTransitive = 246 246 + upLock: nodeName: sourceInfo: follows: 247 247 + evalFlake sourceInfo sourceInfo.outPath upLock nodeName follows follows; 248 248 + 249 249 + evalTopFlake = 250 250 + sourceInfo: pin: 251 251 + let 252 252 + flakeDir = sourceInfo.outPath + (if pin ? dir then "/" + pin.dir else ""); 253 253 + upLockPath = flakeDir + "/flake.lock"; 254 254 + upLock = if pathExists upLockPath then fromJSON (readFile upLockPath) else null; 255 255 + rootNode = if upLock != null then upLock.root else null; 256 256 + f = followsFor pin; 257 257 + in 258 258 + evalFlake sourceInfo flakeDir upLock rootNode f.level f.deep; 259 259 + 260 260 + evalFetch = 261 261 + sourceInfo: pin: subdir: 262 262 + let 263 263 + path = sourceInfo.outPath + subdir; 264 264 + tackPinsPath = path + "/.tack/pins.toml"; 265 265 + hasTack = pathExists tackPinsPath; 266 266 + upPins = if hasTack then fromTOML (readFile tackPinsPath) else { }; 267 267 + f = followsFor pin; 268 268 + # a fetch drill-in is tack-only 269 269 + tackOverrides = resolveFollows ( 270 270 + intersectAttrs (upPins.inputs or { }) (followsForSide "tack" f.level) 271 271 + ); 272 272 + in 273 273 + # a fetch pin is a source tree (path); hand back resolved inputs only when 274 274 + # there are overrides to push into the upstream's .tack 275 275 + if hasTack && tackOverrides != { } then 276 276 + let 277 277 + upstream = import (path + "/.tack"); 278 278 + in 279 279 + # old resolvers return a plain attrset, not a callable functor 280 280 + if upstream ? __functor then 281 281 + (upstream { overrides = tackOverrides; }) // { outPath = path; } 282 282 + else 283 283 + trace "tack: ${path}: upstream .tack predates override support; overrides will not reach it" path 284 284 + else 285 285 + path; 286 286 + 287 287 + loadPin = 288 288 + name: pin: 289 289 + let 290 290 + pinType = pin.type or (if pin.flake or true then "flake" else "fetch"); 291 291 + subdir = if pin ? dir then "/" + pin.dir else ""; 292 292 + in 293 293 + if pinType == "fixed" then 294 294 + fetchFixed name lock.${name} 295 295 + else 296 296 + let 297 297 + sourceInfo = fetchPin name; 298 298 + in 299 299 + if pinType == "flake" then evalTopFlake sourceInfo pin else evalFetch sourceInfo pin subdir; 300 300 + 301 301 + declared = pins.inputs or { }; 302 302 + 303 303 + # undeclared lock entries are auto-dedup synthetics only when referenced as 304 304 + # [all_follow] targets; stale locks from hand-edits are ignored (tack rm to clean) 305 305 + autoTargets = listToAttrs ( 306 306 + map (target: { 307 307 + name = target; 308 308 + value = true; 309 309 + }) (attrValues all_follow) 310 310 + ); 311 311 + autoNames = filter (n: !(declared ? ${n}) && autoTargets ? ${n}) (attrNames lock); 312 312 + autoPin = 313 313 + name: 314 314 + let 315 315 + sourceInfo = fetchPin name; 316 316 + in 317 317 + if pathExists (sourceInfo.outPath + "/flake.nix") then evalTopFlake sourceInfo { } else sourceInfo; 318 318 + 319 319 + self = 320 320 + (mapAttrs loadPin declared) 321 321 + // listToAttrs ( 322 322 + map (name: { 323 323 + inherit name; 324 324 + value = autoPin name; 325 325 + }) autoNames 326 326 + ) 327 327 + // overrides; 328 328 + in 329 329 + self // { __functor = _: call; }; 330 330 + in 331 331 + call { }

+50

.tack/pins.lock.json

Reviewed

··· 1 1 + { 2 2 + "agents": { 3 3 + "type": "github", 4 4 + "owner": "numtide", 5 5 + "repo": "llm-agents.nix", 6 6 + "rev": "437521e14715e95a167faf1c5b8fbb4382c5ac3d", 7 7 + "narHash": "sha256-wTlSeXo/CmbZvdO2sla7JRO/WpYCEHawEDko/FJHeMQ=", 8 8 + "lastModified": 1782243238 9 9 + }, 10 10 + "darwin": { 11 11 + "type": "github", 12 12 + "owner": "nix-darwin", 13 13 + "repo": "nix-darwin", 14 14 + "rev": "a1fa429e945becaf60468600daf649be4ba0350c", 15 15 + "narHash": "sha256-rCPytmKNjctLloB6UgK5CRrHSwV4b0ygxtJLPPp8R14=", 16 16 + "lastModified": 1781761792 17 17 + }, 18 18 + "hjem": { 19 19 + "type": "github", 20 20 + "owner": "feel-co", 21 21 + "repo": "hjem", 22 22 + "rev": "3b110d0e7c07a5652019223bd7f7b872b86f06a4", 23 23 + "narHash": "sha256-1cMArpPnPvjKYNMsMRwtAxQ6ngPnIg/Wt3ohS95fbwY=", 24 24 + "lastModified": 1782071069 25 25 + }, 26 26 + "nixpkgs": { 27 27 + "type": "github", 28 28 + "owner": "nixos", 29 29 + "repo": "nixpkgs", 30 30 + "rev": "b3c092d3c36d91e2f61f3dfb39a159f180a56659", 31 31 + "narHash": "sha256-BnbXO5s5EhV89lLXMAGCzPdEN5a6vNqvMk71obeTEUw=", 32 32 + "lastModified": 1782118813 33 33 + }, 34 34 + "tack": { 35 35 + "type": "github", 36 36 + "owner": "manic-systems", 37 37 + "repo": "tack", 38 38 + "rev": "a834318b7fe7371fce1eaf9c309caeadf57cf9af", 39 39 + "narHash": "sha256-KhJb0NWLhj8AkD8uWEbXt179YlFLemk0OgOltw4jEk8=", 40 40 + "lastModified": 1782001225 41 41 + }, 42 42 + "wsl": { 43 43 + "type": "github", 44 44 + "owner": "nix-community", 45 45 + "repo": "nixos-wsl", 46 46 + "rev": "5675822ba756e6e56f8f6a5a76e90e0da2ece94d", 47 47 + "narHash": "sha256-V5EQQbDnmdiXGQXrEF1PEL7QYsFqfH8N1E89Z5ONwFk=", 48 48 + "lastModified": 1781182279 49 49 + } 50 50 + }

+27

.tack/pins.toml

Reviewed

··· 1 1 + 2 2 + [shorturls] 3 3 + gh = "github:{path}" 4 4 + 5 5 + [all_follow] 6 6 + nixpkgs = "nixpkgs" 7 7 + 8 8 + [inputs.nixpkgs] 9 9 + url = "gh:nixos/nixpkgs/nixpkgs-unstable" 10 10 + 11 11 + [inputs.wsl] 12 12 + url = "gh:nix-community/nixos-wsl/main" 13 13 + 14 14 + [inputs.darwin] 15 15 + url = "gh:nix-darwin/nix-darwin/master" 16 16 + 17 17 + [inputs.hjem] 18 18 + url = "gh:feel-co/hjem/main" 19 19 + 20 20 + [inputs.hjem.follows] 21 21 + nix-darwin = "darwin" 22 22 + 23 23 + [inputs.agents] 24 24 + url = "gh:numtide/llm-agents.nix/main" 25 25 + 26 26 + [inputs.tack] 27 27 + url = "gh:manic-systems/tack/v1.0.0"