@infernetprotocol/cli 0.1.65 → 0.1.67
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/commands/model-temporal.js +305 -0
- package/commands/model.js +11 -1
- package/package.json +13 -12
|
@@ -0,0 +1,305 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* `infernet model train|evaluate|predict|serve|capabilities|runtime|synth` —
|
|
3
|
+
* the temporal-policy family (workloads infernet.temporal.train and
|
|
4
|
+
* infernet.temporal.infer): CfC/LTC liquid networks and a GRU baseline,
|
|
5
|
+
* run by the isolated `infernet-liquid` Python runtime. Node only validates,
|
|
6
|
+
* hashes and pipes NDJSON; Python never loads unless one of these runs.
|
|
7
|
+
*/
|
|
8
|
+
|
|
9
|
+
import { readFile, writeFile, mkdir } from "node:fs/promises";
|
|
10
|
+
import { spawn } from "node:child_process";
|
|
11
|
+
import path from "node:path";
|
|
12
|
+
import {
|
|
13
|
+
FAMILIES,
|
|
14
|
+
LiquidRuntime,
|
|
15
|
+
RUNTIME_DIR,
|
|
16
|
+
SCHEMA_VERSION,
|
|
17
|
+
WORKLOADS,
|
|
18
|
+
assertValid,
|
|
19
|
+
lockHash,
|
|
20
|
+
resolveRuntime,
|
|
21
|
+
setupRuntime,
|
|
22
|
+
verifyBundle
|
|
23
|
+
} from "@infernetprotocol/liquid-agent";
|
|
24
|
+
|
|
25
|
+
export const TEMPORAL_SUBCOMMANDS = new Set(["train", "evaluate", "eval", "predict", "serve", "capabilities", "runtime", "synth"]);
|
|
26
|
+
|
|
27
|
+
export const TEMPORAL_HELP = `
|
|
28
|
+
Temporal policies (workloads ${WORKLOADS.TRAIN}, ${WORKLOADS.INFER}):
|
|
29
|
+
infernet model runtime [status] Is the infernet-liquid runtime installed?
|
|
30
|
+
infernet model runtime setup [--accelerator cpu|cuda] [--yes]
|
|
31
|
+
Install it (PyTorch + ncps from a hash-pinned
|
|
32
|
+
lock, ~1 GB on CPU). Never done implicitly.
|
|
33
|
+
infernet model train --dataset <bundle.json> --output <dir>
|
|
34
|
+
[--family cfc|ltc|gru] [--baseline gru[,ltc]]
|
|
35
|
+
[--epochs N] [--seed N] [--hidden N] [--device auto|cpu|cuda]
|
|
36
|
+
[--job <train-job.json>] [--json]
|
|
37
|
+
Train on a liquid-agent/v1 dataset bundle;
|
|
38
|
+
writes model.safetensors + manifest.json.
|
|
39
|
+
--baseline trains the others on the same
|
|
40
|
+
splits and picks a winner by the rule.
|
|
41
|
+
infernet model evaluate --model <dir> --dataset <bundle.json> [--split test|all] [--json]
|
|
42
|
+
infernet model predict --model <dir> --input <steps.jsonl> [--session <id>]
|
|
43
|
+
Feed observed steps, print action proposals.
|
|
44
|
+
infernet model serve --stdio [--max-sessions N] [--ttl S] [--worker <id>]
|
|
45
|
+
The runtime's NDJSON contract on stdin/stdout
|
|
46
|
+
(what c0mpute's temporal serve drives).
|
|
47
|
+
infernet model capabilities [--json] Runtime, devices, RAM, families.
|
|
48
|
+
infernet model synth --out <bundle.json> [--per-task N] [--seed N] [--shifted]
|
|
49
|
+
Synthetic mock desktop traces (email,
|
|
50
|
+
Reddit, LinkedIn mock sites) for testing.
|
|
51
|
+
`;
|
|
52
|
+
|
|
53
|
+
const flag = (args, name, fallback) => (args.has(name) ? args.get(name) : fallback);
|
|
54
|
+
const intFlag = (args, name) => (args.has(name) ? Number.parseInt(args.get(name), 10) : undefined);
|
|
55
|
+
|
|
56
|
+
function out(args, obj, text) {
|
|
57
|
+
process.stdout.write(args.has("json") ? `${JSON.stringify(obj, null, 2)}\n` : text);
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
async function readJson(p) {
|
|
61
|
+
return JSON.parse(await readFile(p, "utf8"));
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
async function cmdRuntime(args) {
|
|
65
|
+
const sub = args.positional?.[1] ?? "status";
|
|
66
|
+
const accelerator = flag(args, "accelerator", "cpu");
|
|
67
|
+
if (sub === "setup") {
|
|
68
|
+
if (!args.has("yes") && !args.has("y") && process.env.INFERNET_NONINTERACTIVE !== "1") {
|
|
69
|
+
process.stdout.write(
|
|
70
|
+
`This installs the infernet-liquid runtime: Python venv + PyTorch (${accelerator}) + ncps from\n` +
|
|
71
|
+
`${path.relative(process.cwd(), path.join(RUNTIME_DIR, accelerator === "cuda" ? "requirements-cuda.lock" : "requirements.lock"))}\n` +
|
|
72
|
+
`(about ${accelerator === "cuda" ? "5" : "1"} GB). Re-run with --yes to proceed.\n`
|
|
73
|
+
);
|
|
74
|
+
return 1;
|
|
75
|
+
}
|
|
76
|
+
const rt = await setupRuntime({ accelerator, log: (l) => process.stderr.write(`${l}\n`) });
|
|
77
|
+
process.stdout.write(`installed: ${rt.python} (${rt.accelerator}, lock ${lockHash(accelerator)})\n`);
|
|
78
|
+
return 0;
|
|
79
|
+
}
|
|
80
|
+
const rt = resolveRuntime();
|
|
81
|
+
if (!rt) {
|
|
82
|
+
out(args, { installed: false }, "infernet-liquid runtime: not installed (infernet model runtime setup --yes)\n");
|
|
83
|
+
return 1;
|
|
84
|
+
}
|
|
85
|
+
const r = new LiquidRuntime(rt);
|
|
86
|
+
try {
|
|
87
|
+
const h = await r.request("health", {}, { timeoutMs: 120000 });
|
|
88
|
+
out(args, { installed: true, ...rt, health: h }, `infernet-liquid ${h.runtime.version}: python ${h.runtime.python}, torch ${h.runtime.torch}, ncps ${h.runtime.ncps}, cuda ${h.devices.cuda}\n ${rt.source}\n`);
|
|
89
|
+
return 0;
|
|
90
|
+
} finally {
|
|
91
|
+
await r.close();
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
async function cmdCapabilities(args) {
|
|
96
|
+
const rt = resolveRuntime();
|
|
97
|
+
if (!rt) {
|
|
98
|
+
out(args, { workloads: [], runtime: null }, "temporal workloads: none (runtime not installed)\n");
|
|
99
|
+
return 1;
|
|
100
|
+
}
|
|
101
|
+
const r = new LiquidRuntime(rt);
|
|
102
|
+
try {
|
|
103
|
+
const caps = await r.request("capabilities", {}, { timeoutMs: 120000 });
|
|
104
|
+
out(args, caps, `workloads: ${caps.workloads.join(", ")}\nfamilies: ${caps.families.join(", ")} (research: ${caps.research_families.join(", ")})\ncuda: ${caps.devices.cuda} ram: ${caps.ram_mb} MB threads: ${caps.threads}\n`);
|
|
105
|
+
return 0;
|
|
106
|
+
} finally {
|
|
107
|
+
await r.close();
|
|
108
|
+
}
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
function fmtMetrics(m) {
|
|
112
|
+
const f = (k) => (typeof m[k] === "number" ? m[k].toFixed(3) : "n/a");
|
|
113
|
+
return `episode_success ${f("episode_success")} step_accuracy ${f("step_accuracy")} target_accuracy ${f("target_accuracy")} ext_write_recall ${f("external_write_recall")} p50 ${f("latency_ms_p50")} ms`;
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
/** Pick by the PRD rule: a liquid family wins only if it beats every baseline on episode_success. */
|
|
117
|
+
export function selectFamily(results) {
|
|
118
|
+
const baseline = results.find((r) => r.family === "gru") ?? results[0];
|
|
119
|
+
const liquid = results.filter((r) => r.family !== baseline.family);
|
|
120
|
+
const better = liquid
|
|
121
|
+
.filter((r) => r.eval.metrics.episode_success > baseline.eval.metrics.episode_success)
|
|
122
|
+
.sort((a, b) => b.eval.metrics.episode_success - a.eval.metrics.episode_success);
|
|
123
|
+
return better[0] ?? baseline;
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
async function cmdTrain(args) {
|
|
127
|
+
const datasetPath = flag(args, "dataset");
|
|
128
|
+
const output = flag(args, "output");
|
|
129
|
+
if (!datasetPath || !output) {
|
|
130
|
+
process.stderr.write("error: --dataset <bundle.json> and --output <dir> are required\n");
|
|
131
|
+
return 2;
|
|
132
|
+
}
|
|
133
|
+
const bundle = await readJson(datasetPath);
|
|
134
|
+
const datasetHash = verifyBundle(bundle);
|
|
135
|
+
let job = null;
|
|
136
|
+
if (args.has("job")) job = assertValid(await readJson(args.get("job")), "train_job");
|
|
137
|
+
const family = job?.model_type ?? flag(args, "family", "cfc");
|
|
138
|
+
if (!FAMILIES.includes(family)) {
|
|
139
|
+
process.stderr.write(`error: --family must be one of ${FAMILIES.join(", ")}\n`);
|
|
140
|
+
return 2;
|
|
141
|
+
}
|
|
142
|
+
const baselines = String(flag(args, "baseline", (job?.baselines ?? []).join(",")) || "")
|
|
143
|
+
.split(",")
|
|
144
|
+
.map((s) => s.trim())
|
|
145
|
+
.filter((s) => s && s !== family);
|
|
146
|
+
const hyper = Object.fromEntries(
|
|
147
|
+
Object.entries({ epochs: intFlag(args, "epochs"), seed: intFlag(args, "seed"), hidden_units: intFlag(args, "hidden") }).filter(([, v]) => v !== undefined)
|
|
148
|
+
);
|
|
149
|
+
const families = [family, ...baselines];
|
|
150
|
+
const r = new LiquidRuntime();
|
|
151
|
+
const results = [];
|
|
152
|
+
try {
|
|
153
|
+
for (const fam of families) {
|
|
154
|
+
const dir = families.length > 1 ? path.join(output, fam) : output;
|
|
155
|
+
const params = {
|
|
156
|
+
bundle_path: path.resolve(datasetPath),
|
|
157
|
+
output_dir: path.resolve(dir),
|
|
158
|
+
family: fam,
|
|
159
|
+
hyperparameters: hyper,
|
|
160
|
+
device: flag(args, "device", "auto")
|
|
161
|
+
};
|
|
162
|
+
if (job) params.job = fam === family ? job : { ...job, model_type: fam };
|
|
163
|
+
if (!args.has("json")) process.stderr.write(`training ${fam} on ${datasetHash.slice(0, 19)}…\n`);
|
|
164
|
+
const res = await r.request("train", params, {
|
|
165
|
+
timeoutMs: (job?.limits?.timeout_s ?? 6 * 3600) * 1000,
|
|
166
|
+
onEvent: (ev) => {
|
|
167
|
+
if (!args.has("json") && ev.event === "epoch") process.stderr.write(` ${fam} epoch ${ev.epoch} loss ${ev.loss} val_step_acc ${ev.val_step_accuracy}\n`);
|
|
168
|
+
}
|
|
169
|
+
});
|
|
170
|
+
results.push({ family: fam, model_dir: res.model_dir, model_hash: res.manifest.weights.weights_hash, eval: res.eval });
|
|
171
|
+
}
|
|
172
|
+
} finally {
|
|
173
|
+
await r.close();
|
|
174
|
+
}
|
|
175
|
+
const chosen = selectFamily(results);
|
|
176
|
+
if (results.length > 1) {
|
|
177
|
+
await mkdir(output, { recursive: true });
|
|
178
|
+
await writeFile(path.join(output, "comparison.json"), JSON.stringify({ schema_version: SCHEMA_VERSION, dataset_hash: datasetHash, results, selected: chosen.family, rule: "liquid family selected only if it beats the GRU baseline on episode_success" }, null, 2) + "\n");
|
|
179
|
+
}
|
|
180
|
+
let text = "";
|
|
181
|
+
for (const res of results) text += `${res.family.padEnd(4)} ${res.model_hash}\n ${fmtMetrics(res.eval.metrics)}\n ${res.model_dir}\n`;
|
|
182
|
+
if (results.length > 1) text += `selected: ${chosen.family} (a liquid family wins only if it beats the GRU baseline)\n`;
|
|
183
|
+
out(args, { dataset_hash: datasetHash, results, selected: chosen.family }, text);
|
|
184
|
+
return 0;
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
async function cmdEvaluate(args) {
|
|
188
|
+
const model = flag(args, "model");
|
|
189
|
+
const dataset = flag(args, "dataset");
|
|
190
|
+
if (!model || !dataset) {
|
|
191
|
+
process.stderr.write("error: --model <dir> and --dataset <bundle.json> are required\n");
|
|
192
|
+
return 2;
|
|
193
|
+
}
|
|
194
|
+
verifyBundle(await readJson(dataset));
|
|
195
|
+
const r = new LiquidRuntime();
|
|
196
|
+
try {
|
|
197
|
+
const res = await r.request("evaluate", { model_dir: path.resolve(model), bundle_path: path.resolve(dataset), split: flag(args, "split", "test") }, { timeoutMs: 3600 * 1000 });
|
|
198
|
+
out(args, res, `${res.model_hash}\n${res.split}: ${fmtMetrics(res.metrics)}\n`);
|
|
199
|
+
return 0;
|
|
200
|
+
} finally {
|
|
201
|
+
await r.close();
|
|
202
|
+
}
|
|
203
|
+
}
|
|
204
|
+
|
|
205
|
+
async function cmdPredict(args) {
|
|
206
|
+
const model = flag(args, "model");
|
|
207
|
+
const input = flag(args, "input");
|
|
208
|
+
if (!model || !input) {
|
|
209
|
+
process.stderr.write("error: --model <dir> and --input <steps.jsonl> are required\n");
|
|
210
|
+
return 2;
|
|
211
|
+
}
|
|
212
|
+
const steps = (await readFile(input, "utf8")).split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
|
|
213
|
+
const sessionId = flag(args, "session", `local-${Date.now()}`);
|
|
214
|
+
const r = new LiquidRuntime();
|
|
215
|
+
try {
|
|
216
|
+
const loaded = await r.request("load", { model_dir: path.resolve(model), abstain_threshold: Number(flag(args, "threshold", 0.5)) }, { timeoutMs: 120000 });
|
|
217
|
+
await r.request("open_session", { model_hash: loaded.model_hash, session_id: sessionId });
|
|
218
|
+
let prev = null;
|
|
219
|
+
for (const [i, step] of steps.entries()) {
|
|
220
|
+
const request = {
|
|
221
|
+
schema_version: SCHEMA_VERSION,
|
|
222
|
+
kind: "predict_request",
|
|
223
|
+
session_id: sessionId,
|
|
224
|
+
model_hash: loaded.model_hash,
|
|
225
|
+
sequence_index: i,
|
|
226
|
+
dt_ms: step.dt_ms ?? 0,
|
|
227
|
+
...(step.task ? { task: step.task } : {}),
|
|
228
|
+
observation: step.observation,
|
|
229
|
+
prev_action: step.prev_action ?? prev
|
|
230
|
+
};
|
|
231
|
+
const p = await r.request("predict", { request });
|
|
232
|
+
process.stdout.write(`${JSON.stringify(p)}\n`);
|
|
233
|
+
prev = step.action ?? p.action;
|
|
234
|
+
}
|
|
235
|
+
await r.request("close_session", { session_id: sessionId });
|
|
236
|
+
return 0;
|
|
237
|
+
} finally {
|
|
238
|
+
await r.close();
|
|
239
|
+
}
|
|
240
|
+
}
|
|
241
|
+
|
|
242
|
+
function passthrough(rt, pyArgs) {
|
|
243
|
+
return new Promise((resolve) => {
|
|
244
|
+
const child = spawn(rt.python, ["-m", "infernet_liquid", ...pyArgs], {
|
|
245
|
+
stdio: "inherit",
|
|
246
|
+
env: { ...process.env, PYTHONPATH: RUNTIME_DIR, PYTHONUNBUFFERED: "1", INFERNET_LIQUID_LOCK: rt.accelerator }
|
|
247
|
+
});
|
|
248
|
+
child.on("exit", (code) => resolve(code ?? 1));
|
|
249
|
+
child.on("error", (e) => {
|
|
250
|
+
process.stderr.write(`error: ${e.message}\n`);
|
|
251
|
+
resolve(1);
|
|
252
|
+
});
|
|
253
|
+
});
|
|
254
|
+
}
|
|
255
|
+
|
|
256
|
+
function requireRuntime() {
|
|
257
|
+
const rt = resolveRuntime();
|
|
258
|
+
if (!rt) process.stderr.write("error: the infernet-liquid runtime is not installed; run `infernet model runtime setup --yes`\n");
|
|
259
|
+
return rt;
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
async function cmdServe(args) {
|
|
263
|
+
const rt = requireRuntime();
|
|
264
|
+
if (!rt) return 1;
|
|
265
|
+
const extra = [];
|
|
266
|
+
if (args.has("max-sessions")) extra.push("--max-sessions", String(args.get("max-sessions")));
|
|
267
|
+
if (args.has("ttl")) extra.push("--ttl", String(args.get("ttl")));
|
|
268
|
+
if (args.has("worker")) extra.push("--worker", String(args.get("worker")));
|
|
269
|
+
return passthrough(rt, ["serve", ...extra]);
|
|
270
|
+
}
|
|
271
|
+
|
|
272
|
+
async function cmdSynth(args) {
|
|
273
|
+
const rt = requireRuntime();
|
|
274
|
+
if (!rt) return 1;
|
|
275
|
+
const outPath = flag(args, "out");
|
|
276
|
+
if (!outPath) {
|
|
277
|
+
process.stderr.write("error: --out <bundle.json> is required\n");
|
|
278
|
+
return 2;
|
|
279
|
+
}
|
|
280
|
+
const pyArgs = ["synth", "--out", path.resolve(outPath), "--per-task", String(flag(args, "per-task", 160)), "--seed", String(flag(args, "seed", 7))];
|
|
281
|
+
if (args.has("shifted")) pyArgs.push("--shifted");
|
|
282
|
+
return passthrough(rt, pyArgs);
|
|
283
|
+
}
|
|
284
|
+
|
|
285
|
+
export async function runTemporal(sub, args) {
|
|
286
|
+
switch (sub) {
|
|
287
|
+
case "runtime":
|
|
288
|
+
return cmdRuntime(args);
|
|
289
|
+
case "capabilities":
|
|
290
|
+
return cmdCapabilities(args);
|
|
291
|
+
case "train":
|
|
292
|
+
return cmdTrain(args);
|
|
293
|
+
case "evaluate":
|
|
294
|
+
case "eval":
|
|
295
|
+
return cmdEvaluate(args);
|
|
296
|
+
case "predict":
|
|
297
|
+
return cmdPredict(args);
|
|
298
|
+
case "serve":
|
|
299
|
+
return cmdServe(args);
|
|
300
|
+
case "synth":
|
|
301
|
+
return cmdSynth(args);
|
|
302
|
+
default:
|
|
303
|
+
throw new Error(`not a temporal subcommand: ${sub}`);
|
|
304
|
+
}
|
|
305
|
+
}
|
package/commands/model.js
CHANGED
|
@@ -29,6 +29,7 @@ import {
|
|
|
29
29
|
import { recommendModels } from "../lib/recommender.js";
|
|
30
30
|
import { resolveClientOptions } from "../lib/reservations-client.js";
|
|
31
31
|
import { fetchNodeModels, formatNodeModels } from "../lib/node-models.js";
|
|
32
|
+
import { TEMPORAL_HELP, TEMPORAL_SUBCOMMANDS, runTemporal } from "./model-temporal.js";
|
|
32
33
|
|
|
33
34
|
const HELP = `infernet model — manage models served by this node
|
|
34
35
|
|
|
@@ -60,7 +61,7 @@ Examples:
|
|
|
60
61
|
|
|
61
62
|
Defaults are stored in ~/.config/infernet/config.json under engine.*
|
|
62
63
|
and consumed by the daemon and \`infernet chat\`.
|
|
63
|
-
`;
|
|
64
|
+
${TEMPORAL_HELP}`;
|
|
64
65
|
|
|
65
66
|
const DEFAULT_HOST = "http://localhost:11434";
|
|
66
67
|
|
|
@@ -576,6 +577,15 @@ export default async function model(args) {
|
|
|
576
577
|
const sub = positional[0];
|
|
577
578
|
const arg = positional[1];
|
|
578
579
|
|
|
580
|
+
if (TEMPORAL_SUBCOMMANDS.has(sub)) {
|
|
581
|
+
try {
|
|
582
|
+
return await runTemporal(sub, args);
|
|
583
|
+
} catch (err) {
|
|
584
|
+
process.stderr.write(`error: ${err?.code ? `${err.code}: ` : ""}${err?.message ?? err}\n`);
|
|
585
|
+
return 1;
|
|
586
|
+
}
|
|
587
|
+
}
|
|
588
|
+
|
|
579
589
|
const cfg = (await loadConfig()) ?? {};
|
|
580
590
|
const host = resolveHost(cfg);
|
|
581
591
|
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@infernetprotocol/cli",
|
|
3
|
-
"version": "0.1.
|
|
3
|
+
"version": "0.1.67",
|
|
4
4
|
"description": "GPU-node CLI / daemon for the Infernet Protocol — register a GPU server with a Supabase control plane and start earning.",
|
|
5
5
|
"license": "MIT",
|
|
6
6
|
"type": "module",
|
|
@@ -22,20 +22,21 @@
|
|
|
22
22
|
"node": ">=18"
|
|
23
23
|
},
|
|
24
24
|
"dependencies": {
|
|
25
|
-
"@noble/ciphers": "^2.
|
|
26
|
-
"@noble/curves": "^2.
|
|
27
|
-
"@noble/hashes": "^2.
|
|
25
|
+
"@noble/ciphers": "^2.4.0",
|
|
26
|
+
"@noble/curves": "^2.4.0",
|
|
27
|
+
"@noble/hashes": "^2.4.0",
|
|
28
28
|
"blessed": "^0.1.81",
|
|
29
|
-
"dotenv": "^
|
|
30
|
-
"ora": "^9.4.
|
|
29
|
+
"dotenv": "^18.0.9",
|
|
30
|
+
"ora": "^9.4.1",
|
|
31
31
|
"react": "^17.0.2",
|
|
32
32
|
"react-blessed": "^0.7.2",
|
|
33
|
-
"@infernetprotocol/
|
|
34
|
-
"@infernetprotocol/
|
|
35
|
-
"@infernetprotocol/
|
|
36
|
-
"@infernetprotocol/gpu": "0.1.
|
|
37
|
-
"@infernetprotocol/engine": "0.1.
|
|
38
|
-
"@infernetprotocol/rpc-adapter": "0.1.
|
|
33
|
+
"@infernetprotocol/config": "0.1.67",
|
|
34
|
+
"@infernetprotocol/deploy-providers": "0.1.67",
|
|
35
|
+
"@infernetprotocol/auth": "0.1.67",
|
|
36
|
+
"@infernetprotocol/gpu": "0.1.67",
|
|
37
|
+
"@infernetprotocol/engine": "0.1.67",
|
|
38
|
+
"@infernetprotocol/rpc-adapter": "0.1.67",
|
|
39
|
+
"@infernetprotocol/liquid-agent": "0.1.67"
|
|
39
40
|
},
|
|
40
41
|
"repository": {
|
|
41
42
|
"type": "git",
|