Milestone 0.1: source control view, diffs over the oxy: scheme, quick diff, decorations, status bar, commit, quick-pick log; process wrapper with a Node test; packaging bed495a96408

Author: Andy McCall @andymccall <[email protected]>
When: 1 month ago · 2026-09-27 15:10 UTC
Signature: ✔ signed by Andy McCall
Hash: bed495a96408da78fc1c66f82c024c3d70e163f6a088fd3af3d1d44f5b294256
Depends on: 3006b700c514
Depended on by: 390a91e2e39c dac6876e4d08 9f29d3164a2a c530a43af73b ca2304a7851a 3701d06abc9b 26410312ce16 6e06e5a13d17 691d366b4c69 813df1a92fbb b55e0d00545e 013fefef11e3 0c26846a9a81 196392053c9f f532c4266f21 0072c2b27293 cdcffe39dd9f 1f7fc1e3ae4a 44bfd5adfc9a b4626290e660 9627171e23e2 f6bda77ecb9f 9020cf612749 d2c9a5843004 25103dddd993 ab81294a9ba9 c8f955891224 5779e5c731a6 35d56b5803d9 810a1c538e78 71d8bf9717d2
In bookmarks: main
In tags: v0.16.0 v0.16.1 v0.17.0 v0.17.1 v0.18.0
Edits: 16 atoms, 19 tree operations, 16 files

Browse the tree at this change

hide whitespace changes

added .vscode/launch.json +13 −0

added .vscode/tasks.json +19 −0

added .vscodeignore +8 −0

added CHANGELOG.md +9 −0

added LICENSE +30 −0

added README.md +35 −0

added assets/images/oxygen.png +0 −0

No line changes.

added package-lock.json +2372 −0

added package.json +95 −0

added src/contentProvider.ts +62 −0

added src/decorations.ts +63 −0

added src/extension.ts +188 −0

added src/oxy.ts +205 −0

added src/repository.ts +231 −0

added test/oxy.test.mjs +47 −0

added tsconfig.json +18 −0

1	+	{
2	+	"version": "0.2.0",
3	+	"configurations": [
4	+	{
5	+	"name": "Run Extension",
6	+	"type": "extensionHost",
7	+	"request": "launch",
8	+	"args": ["--extensionDevelopmentPath=${workspaceFolder}", "${workspaceFolder}/../hellooxy"],
9	+	"outFiles": ["${workspaceFolder}/dist/*/.js"],
10	+	"preLaunchTask": "npm: build"
11	+	}
12	+	]
13	+	}

1	+	{
2	+	"version": "2.0.0",
3	+	"tasks": [
4	+	{
5	+	"type": "npm",
6	+	"script": "build",
7	+	"group": "build",
8	+	"problemMatcher": ["$esbuild"],
9	+	"label": "npm: build"
10	+	},
11	+	{
12	+	"type": "npm",
13	+	"script": "watch",
14	+	"isBackground": true,
15	+	"problemMatcher": ["$esbuild-watch"],
16	+	"label": "npm: watch"
17	+	}
18	+	]
19	+	}

1	+	.oxy/**
2	+	.oxyignore
3	+	src/**
4	+	test/**
5	+	out/**
6	+	node_modules/**
7	+	tsconfig.json
8	+	*/.map

1	+	# Changelog
2	+
3	+	## 0.1.0 (2026-09-27)
4	+
5	+	Milestone 0.1 of the spec: Source Control view with Changes and Conflicts,
6	+	diff of a file against the working copy's base over the `oxy:` scheme,
7	+	quick-diff gutters, explorer and tab decorations, a status bar item fed by
8	+	`oxy prompt`, commit from the input box, a quick-pick log, and an output
9	+	channel logging every `oxy` invocation.

1	+	Oxygen for Visual Studio Code is licensed under either of
2	+
3	+	* the MIT License (below), or
4	+	* the Apache License, Version 2.0 (https://www.apache.org/licenses/LICENSE-2.0)
5	+
6	+	at your option, as is Oxygen itself.
7	+
8	+	---
9	+
10	+	MIT License
11	+
12	+	Copyright (c) 2026 Andy McCall
13	+
14	+	Permission is hereby granted, free of charge, to any person obtaining a copy
15	+	of this software and associated documentation files (the "Software"), to deal
16	+	in the Software without restriction, including without limitation the rights
17	+	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
18	+	copies of the Software, and to permit persons to whom the Software is
19	+	furnished to do so, subject to the following conditions:
20	+
21	+	The above copyright notice and this permission notice shall be included in all
22	+	copies or substantial portions of the Software.
23	+
24	+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25	+	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26	+	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
27	+	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28	+	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
29	+	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30	+	SOFTWARE.

1	+	# Oxygen for Visual Studio Code
2	+
3	+	Source control integration for Oxygen (`oxy`) repositories: a
4	+	Source Control view with changes and conflicts, diffs against the working
5	+	copy's base, quick-diff gutters, explorer decorations, a status bar item, and
6	+	commit from the input box. The full design, milestone by milestone, is in
7	+	`docs/spec.md` in this repository.
8	+
9	+	## Requirements
10	+
11	+	- Visual Studio Code 1.137 or later.
12	+	- `oxy` 0.1 or later on your PATH, at `~/.local/bin/oxy`, or named in the
13	+	`oxygen.path` setting. The extension drives `oxy --json` and never reads
14	+	`.oxy/` itself.
15	+
16	+	## Building
17	+
18	+	```
19	+	npm install
20	+	npm run check # typecheck, bundle, and test against the oxy binary
21	+	npm run package # oxygen-vscode-<version>.vsix
22	+	code --install-extension oxygen-vscode-0.1.0.vsix
23	+	```
24	+
25	+	`npm run watch` rebuilds on change; press F5 in VS Code to launch an
26	+	Extension Development Host with the bundle.
27	+
28	+	## Status
29	+
30	+	Milestone 0.1 (read-only plus commit) of the spec. Bookmarks, sync, history,
31	+	blame, conflicts, subrepos, bisect and trust views follow in 0.2 to 0.6.
32	+
33	+	## Licence
34	+
35	+	MIT or Apache-2.0, at your option, as for Oxygen itself.

1	+	{
2	+	"name": "oxygen-vscode",
3	+	"displayName": "Oxygen",
4	+	"description": "Oxygen version control: source control view, diffs, decorations, bookmarks and history for oxy repositories",
5	+	"version": "0.1.0",
6	+	"publisher": "oxygen",
7	+	"license": "MIT OR Apache-2.0",
8	+	"icon": "assets/images/oxygen.png",
9	+	"engines": {
10	+	"vscode": "^1.137.0"
11	+	},
12	+	"categories": [
13	+	"SCM Providers"
14	+	],
15	+	"keywords": [
16	+	"oxygen",
17	+	"oxy",
18	+	"scm",
19	+	"version control"
20	+	],
21	+	"activationEvents": [
22	+	"workspaceContains:.oxy"
23	+	],
24	+	"main": "./dist/extension.js",
25	+	"contributes": {
26	+	"commands": [
27	+	{ "command": "oxygen.refresh", "title": "Refresh", "category": "Oxygen", "icon": "$(refresh)" },
28	+	{ "command": "oxygen.commit", "title": "Commit", "category": "Oxygen", "icon": "$(check)" },
29	+	{ "command": "oxygen.openFile", "title": "Open File", "category": "Oxygen", "icon": "$(go-to-file)" },
30	+	{ "command": "oxygen.openChanges", "title": "Open Changes", "category": "Oxygen" },
31	+	{ "command": "oxygen.openBaseVersion", "title": "Open Base Version", "category": "Oxygen" },
32	+	{ "command": "oxygen.showOutput", "title": "Show Output", "category": "Oxygen" },
33	+	{ "command": "oxygen.showLog", "title": "Show Log", "category": "Oxygen" }
34	+	],
35	+	"menus": {
36	+	"scm/title": [
37	+	{ "command": "oxygen.commit", "group": "navigation@1", "when": "scmProvider == oxygen" },
38	+	{ "command": "oxygen.refresh", "group": "navigation@2", "when": "scmProvider == oxygen" },
39	+	{ "command": "oxygen.showLog", "group": "1_view", "when": "scmProvider == oxygen" },
40	+	{ "command": "oxygen.showOutput", "group": "1_view", "when": "scmProvider == oxygen" }
41	+	],
42	+	"scm/resourceState/context": [
43	+	{ "command": "oxygen.openFile", "group": "inline", "when": "scmProvider == oxygen" },
44	+	{ "command": "oxygen.openChanges", "group": "navigation", "when": "scmProvider == oxygen" },
45	+	{ "command": "oxygen.openBaseVersion", "group": "navigation", "when": "scmProvider == oxygen" }
46	+	],
47	+	"commandPalette": [
48	+	{ "command": "oxygen.openFile", "when": "false" },
49	+	{ "command": "oxygen.openChanges", "when": "false" },
50	+	{ "command": "oxygen.openBaseVersion", "when": "false" }
51	+	]
52	+	},
53	+	"configuration": {
54	+	"title": "Oxygen",
55	+	"properties": {
56	+	"oxygen.path": {
57	+	"type": "string",
58	+	"default": "",
59	+	"description": "Path to the oxy binary. Empty means oxy on PATH, then ~/.local/bin/oxy."
60	+	},
61	+	"oxygen.autoRefresh": {
62	+	"type": "boolean",
63	+	"default": true,
64	+	"description": "Refresh the source control view when files in the workspace change."
65	+	},
66	+	"oxygen.decorations.enabled": {
67	+	"type": "boolean",
68	+	"default": true,
69	+	"description": "Show status decorations in the explorer and on editor tabs."
70	+	},
71	+	"oxygen.statusBar.enabled": {
72	+	"type": "boolean",
73	+	"default": true,
74	+	"description": "Show the bookmark, working copy and state in the status bar."
75	+	}
76	+	}
77	+	}
78	+	},
79	+	"scripts": {
80	+	"build": "esbuild src/extension.ts --bundle --platform=node --format=cjs --external:vscode --outfile=dist/extension.js --sourcemap",
81	+	"watch": "npm run build -- --watch",
82	+	"typecheck": "tsc --noEmit -p .",
83	+	"pretest": "esbuild src/oxy.ts --bundle --platform=node --format=esm --outfile=out/oxy.mjs",
84	+	"test": "node --test \"test/*/.test.mjs\"",
85	+	"check": "npm run typecheck && npm run build && npm test",
86	+	"package": "vsce package --no-dependencies"
87	+	},
88	+	"devDependencies": {
89	+	"@types/node": "^24.0.0",
90	+	"@types/vscode": "^1.137.0",
91	+	"@vscode/vsce": "^4.0.0",
92	+	"esbuild": "^0.28.0",
93	+	"typescript": "^5.9.0"
94	+	}
95	+	}

1	+	// The `oxy:` URI scheme serves file content at a state through `oxy cat`
2	+	// (spec §3): oxy:/<repository-relative path>?root=<repository root>&change=<change>
3	+	// where `change` is `@base` (the working copy's base) or anything
4	+	// `oxy cat -r` accepts.
5	+
6	+	import * as vscode from "vscode";
7	+	import { Oxy } from "./oxy";
8	+
9	+	export const SCHEME = "oxy";
10	+
11	+	export function oxyUri(root: string, path: string, change: string): vscode.Uri {
12	+	const query = new URLSearchParams({ root, change }).toString();
13	+	return vscode.Uri.from({ scheme: SCHEME, path: "/" + path, query });
14	+	}
15	+
16	+	export function baseUri(root: string, path: string): vscode.Uri {
17	+	return oxyUri(root, path, "@base");
18	+	}
19	+
20	+	export function parseOxyUri(uri: vscode.Uri): { root: string; path: string; change: string } \| undefined {
21	+	if (uri.scheme !== SCHEME) {
22	+	return undefined;
23	+	}
24	+	const q = new URLSearchParams(uri.query);
25	+	const root = q.get("root");
26	+	const change = q.get("change") ?? "@base";
27	+	if (!root) {
28	+	return undefined;
29	+	}
30	+	return { root, path: uri.path.replace(/^\//, ""), change };
31	+	}
32	+
33	+	export class OxyContentProvider implements vscode.TextDocumentContentProvider {
34	+	private readonly emitter = new vscode.EventEmitter<vscode.Uri>();
35	+	readonly onDidChange = this.emitter.event;
36	+
37	+	constructor(private readonly oxy: Oxy) {}
38	+
39	+	/** Tell open `oxy:` documents under `root` to reload (after an operation). */
40	+	invalidate(root: string): void {
41	+	for (const doc of vscode.workspace.textDocuments) {
42	+	const parsed = parseOxyUri(doc.uri);
43	+	if (parsed && parsed.root === root && parsed.change === "@base") {
44	+	this.emitter.fire(doc.uri);
45	+	}
46	+	}
47	+	}
48	+
49	+	async provideTextDocumentContent(uri: vscode.Uri): Promise<string> {
50	+	const parsed = parseOxyUri(uri);
51	+	if (!parsed) {
52	+	return "";
53	+	}
54	+	try {
55	+	const bytes = await this.oxy.cat(parsed.root, parsed.path, parsed.change === "@base" ? undefined : parsed.change);
56	+	return bytes.toString("utf8");
57	+	} catch {
58	+	// A path absent from that state (an added file's base) is empty.
59	+	return "";
60	+	}
61	+	}
62	+	}

1	+	// Explorer and tab decorations from each repository's latest status (spec §5.1).
2	+
3	+	import * as vscode from "vscode";
4	+	import { Repository } from "./repository";
5	+
6	+	export class OxyDecorationProvider implements vscode.FileDecorationProvider, vscode.Disposable {
7	+	private readonly emitter = new vscode.EventEmitter<vscode.Uri \| vscode.Uri[] \| undefined>();
8	+	readonly onDidChangeFileDecorations = this.emitter.event;
9	+	private readonly disposables: vscode.Disposable[] = [];
10	+
11	+	constructor(private readonly repositories: () => Repository[]) {
12	+	this.disposables.push(vscode.window.registerFileDecorationProvider(this), this.emitter);
13	+	}
14	+
15	+	/** Call when a repository's status changed; every decoration is recomputed. */
16	+	refresh(): void {
17	+	this.emitter.fire(undefined);
18	+	}
19	+
20	+	provideFileDecoration(uri: vscode.Uri): vscode.FileDecoration \| undefined {
21	+	if (!vscode.workspace.getConfiguration("oxygen").get<boolean>("decorations.enabled", true)) {
22	+	return undefined;
23	+	}
24	+	for (const repo of this.repositories()) {
25	+	const rel = repo.relativePath(uri);
26	+	if (rel === undefined \|\| !repo.status) {
27	+	continue;
28	+	}
29	+	const entry = repo.status.paths.find((p) => p.path === rel);
30	+	const conflict = repo.status.conflicts.find((c) => c.path === rel);
31	+	if (conflict && !entry) {
32	+	return new vscode.FileDecoration("‼", "conflict", new vscode.ThemeColor("gitDecoration.conflictingResourceForeground"));
33	+	}
34	+	if (!entry) {
35	+	// A directory containing changes gets a dot, like Git.
36	+	if (repo.status.paths.some((p) => p.path.startsWith(rel + "/"))) {
37	+	return new vscode.FileDecoration("•", "contains changes", new vscode.ThemeColor("gitDecoration.modifiedResourceForeground"));
38	+	}
39	+	continue;
40	+	}
41	+	const letters: Record<string, [string, string, string]> = {
42	+	Added: ["A", "added", "gitDecoration.addedResourceForeground"],
43	+	Modified: ["M", "modified", "gitDecoration.modifiedResourceForeground"],
44	+	Removed: ["D", "removed", "gitDecoration.deletedResourceForeground"],
45	+	Renamed: ["R", "renamed", "gitDecoration.renamedResourceForeground"],
46	+	ModeChanged: ["X", "mode changed", "gitDecoration.modifiedResourceForeground"],
47	+	ConflictEdited: ["‼", "conflict markers remain", "gitDecoration.conflictingResourceForeground"],
48	+	Resolved: ["✔", "conflict resolved", "gitDecoration.stageModifiedResourceForeground"],
49	+	};
50	+	const [badge, tooltip, color] = letters[entry.status] ?? ["?", entry.status, "gitDecoration.modifiedResourceForeground"];
51	+	const d = new vscode.FileDecoration(badge, tooltip, new vscode.ThemeColor(color));
52	+	d.propagate = false;
53	+	return d;
54	+	}
55	+	return undefined;
56	+	}
57	+
58	+	dispose(): void {
59	+	for (const d of this.disposables) {
60	+	d.dispose();
61	+	}
62	+	}
63	+	}

1	+	// Activation: find oxy, find repositories, wire the source control view,
2	+	// decorations, the content provider, and the commands (spec §3).
3	+
4	+	import * as vscode from "vscode";
5	+	import { basename } from "node:path";
6	+	import { Oxy, OxyError, findBinary } from "./oxy";
7	+	import { Repository, OxyResourceState } from "./repository";
8	+	import { OxyContentProvider, SCHEME, baseUri } from "./contentProvider";
9	+	import { OxyDecorationProvider } from "./decorations";
10	+
11	+	const MIN_VERSION = { format: 2, protocol: 1 };
12	+
13	+	let output: vscode.OutputChannel;
14	+	let oxy: Oxy;
15	+	let contentProvider: OxyContentProvider;
16	+	let decorations: OxyDecorationProvider;
17	+	const repositories = new Map<string, Repository>();
18	+
19	+	export async function activate(context: vscode.ExtensionContext): Promise<void> {
20	+	output = vscode.window.createOutputChannel("Oxygen");
21	+	context.subscriptions.push(output);
22	+	oxy = new Oxy(findBinary(vscode.workspace.getConfiguration("oxygen").get<string>("path")), (line) => output.appendLine(line));
23	+
24	+	try {
25	+	const v = await oxy.version();
26	+	output.appendLine(`oxy ${v.version} (format ${v.format}, protocol ${v.protocol}) at ${oxy.binary}`);
27	+	if (v.format < MIN_VERSION.format \|\| v.protocol < MIN_VERSION.protocol) {
28	+	void vscode.window.showWarningMessage(`Oxygen: oxy ${v.version} is older than this extension supports.`);
29	+	}
30	+	} catch (e) {
31	+	const pick = await vscode.window.showErrorMessage(`Oxygen: could not run oxy (${(e as Error).message}). Set "oxygen.path" or put oxy on your PATH.`, "Open Settings");
32	+	if (pick === "Open Settings") {
33	+	void vscode.commands.executeCommand("workbench.action.openSettings", "oxygen.path");
34	+	}
35	+	return;
36	+	}
37	+
38	+	contentProvider = new OxyContentProvider(oxy);
39	+	context.subscriptions.push(vscode.workspace.registerTextDocumentContentProvider(SCHEME, contentProvider));
40	+	decorations = new OxyDecorationProvider(() => [...repositories.values()]);
41	+	context.subscriptions.push(decorations);
42	+
43	+	context.subscriptions.push(
44	+	vscode.commands.registerCommand("oxygen.refresh", async () => {
45	+	await Promise.all([...repositories.values()].map((r) => r.refresh()));
46	+	}),
47	+	vscode.commands.registerCommand("oxygen.showOutput", () => output.show()),
48	+	vscode.commands.registerCommand("oxygen.openFile", (state?: OxyResourceState) => state && vscode.commands.executeCommand("vscode.open", state.resourceUri)),
49	+	vscode.commands.registerCommand("oxygen.openChanges", (state?: OxyResourceState) => state && openChanges(state)),
50	+	vscode.commands.registerCommand("oxygen.openBaseVersion", (state?: OxyResourceState) => state && vscode.commands.executeCommand("vscode.open", baseUri(state.repository.root, state.path))),
51	+	vscode.commands.registerCommand("oxygen.commit", (arg?: Repository \| vscode.SourceControl) => commit(arg)),
52	+	vscode.commands.registerCommand("oxygen.showLog", () => showLog()),
53	+	vscode.workspace.onDidChangeWorkspaceFolders(() => void discover()),
54	+	vscode.workspace.onDidChangeConfiguration((e) => {
55	+	if (e.affectsConfiguration("oxygen.path")) {
56	+	void vscode.window.showInformationMessage("Oxygen: reload the window to use the new oxy path.");
57	+	}
58	+	if (e.affectsConfiguration("oxygen")) {
59	+	decorations.refresh();
60	+	for (const r of repositories.values()) {
61	+	r.scheduleRefresh();
62	+	}
63	+	}
64	+	}),
65	+	);
66	+	context.subscriptions.push({ dispose: () => repositories.forEach((r) => r.dispose()) });
67	+
68	+	await discover();
69	+	}
70	+
71	+	export function deactivate(): void {
72	+	for (const r of repositories.values()) {
73	+	r.dispose();
74	+	}
75	+	repositories.clear();
76	+	}
77	+
78	+	/** One Repository per distinct oxy root among the workspace folders. */
79	+	async function discover(): Promise<void> {
80	+	const wanted = new Map<string, vscode.WorkspaceFolder>();
81	+	for (const folder of vscode.workspace.workspaceFolders ?? []) {
82	+	const info = await oxy.root(folder.uri.fsPath);
83	+	if (info) {
84	+	wanted.set(info.root, folder);
85	+	}
86	+	}
87	+	for (const [root, repo] of repositories) {
88	+	if (!wanted.has(root)) {
89	+	repo.dispose();
90	+	repositories.delete(root);
91	+	}
92	+	}
93	+	for (const [root, folder] of wanted) {
94	+	if (!repositories.has(root)) {
95	+	const repo = new Repository(oxy, root, folder);
96	+	repo.onDidChangeStatus(() => {
97	+	decorations.refresh();
98	+	contentProvider.invalidate(root);
99	+	});
100	+	repositories.set(root, repo);
101	+	output.appendLine(`repository ${root}`);
102	+	await repo.refresh();
103	+	}
104	+	}
105	+	void vscode.commands.executeCommand("setContext", "oxygen.hasRepository", repositories.size > 0);
106	+	}
107	+
108	+	function repositoryFor(arg: Repository \| vscode.SourceControl \| undefined): Repository \| undefined {
109	+	if (arg instanceof Repository) {
110	+	return arg;
111	+	}
112	+	if (arg && "rootUri" in arg && arg.rootUri) {
113	+	return repositories.get(arg.rootUri.fsPath);
114	+	}
115	+	const active = vscode.window.activeTextEditor?.document.uri;
116	+	for (const repo of repositories.values()) {
117	+	if (active && repo.relativePath(active) !== undefined) {
118	+	return repo;
119	+	}
120	+	}
121	+	return repositories.size === 1 ? [...repositories.values()][0] : undefined;
122	+	}
123	+
124	+	async function openChanges(state: OxyResourceState): Promise<void> {
125	+	const repo = state.repository;
126	+	const title = `${basename(state.path)} (base ↔ working copy)`;
127	+	if (state.status === "Added") {
128	+	await vscode.commands.executeCommand("vscode.open", state.resourceUri);
129	+	return;
130	+	}
131	+	if (state.status === "Removed") {
132	+	await vscode.commands.executeCommand("vscode.open", baseUri(repo.root, state.path));
133	+	return;
134	+	}
135	+	await vscode.commands.executeCommand("vscode.diff", baseUri(repo.root, state.path), state.resourceUri, title);
136	+	}
137	+
138	+	async function commit(arg: Repository \| vscode.SourceControl \| undefined): Promise<void> {
139	+	const repo = repositoryFor(arg);
140	+	if (!repo) {
141	+	void vscode.window.showErrorMessage("Oxygen: no repository for the active file.");
142	+	return;
143	+	}
144	+	let message = repo.sourceControl.inputBox.value.trim();
145	+	if (!message) {
146	+	message = (await vscode.window.showInputBox({ prompt: "Commit message", placeHolder: "What did you change?" }))?.trim() ?? "";
147	+	}
148	+	if (!message) {
149	+	return;
150	+	}
151	+	try {
152	+	await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: "Committing" }, () => repo.oxy.commit(repo.root, message));
153	+	repo.sourceControl.inputBox.value = "";
154	+	await repo.refresh();
155	+	} catch (e) {
156	+	showError(e);
157	+	}
158	+	}
159	+
160	+	async function showLog(): Promise<void> {
161	+	const repo = repositoryFor(undefined);
162	+	if (!repo) {
163	+	return;
164	+	}
165	+	try {
166	+	const log = await repo.oxy.log(repo.root, 50);
167	+	const items = log.changes
168	+	.filter((c) => !c.working_copy)
169	+	.map((c) => ({
170	+	label: `${c.head ? "$(circle-filled)" : "$(circle-outline)"} ${c.message.split("\n")[0]}`,
171	+	description: `${c.change_id.slice(0, 8)} · ${c.author}`,
172	+	detail: `${new Date(c.when_ms).toLocaleString()} · ${c.signature?.status ?? "unsigned"}${c.signature?.revoked ? " (key revoked)" : ""}`,
173	+	change: c,
174	+	}));
175	+	const pick = await vscode.window.showQuickPick(items, { placeHolder: `${log.bookmark}: ${log.total - 1} changes`, matchOnDescription: true, matchOnDetail: true });
176	+	if (pick) {
177	+	const doc = await vscode.workspace.openTextDocument({ content: pick.change.message, language: "markdown" });
178	+	await vscode.window.showTextDocument(doc, { preview: true });
179	+	}
180	+	} catch (e) {
181	+	showError(e);
182	+	}
183	+	}
184	+
185	+	function showError(e: unknown): void {
186	+	const message = e instanceof OxyError ? e.message : String(e);
187	+	void vscode.window.showErrorMessage(`Oxygen: ${message}`, "Show Output").then((pick) => pick && output.show());
188	+	}

1	+	// The oxy process wrapper: one function per command the extension uses,
2	+	// all through `oxy --plain --json` (spec §4). This module never imports
3	+	// the vscode API so it can be tested with plain Node.
4	+
5	+	import { execFile } from "node:child_process";
6	+	import { existsSync } from "node:fs";
7	+	import { homedir } from "node:os";
8	+	import { join } from "node:path";
9	+
10	+	export interface RunResult {
11	+	code: number;
12	+	stdout: Buffer;
13	+	stderr: string;
14	+	}
15	+
16	+	export class OxyError extends Error {
17	+	constructor(
18	+	public readonly args: string[],
19	+	public readonly code: number,
20	+	public readonly stderr: string,
21	+	) {
22	+	super(stderr.trim() \|\| `oxy ${args.join(" ")} exited with status ${code}`);
23	+	this.name = "OxyError";
24	+	}
25	+	}
26	+
27	+	/** Where to find `oxy`: the configured path, else `oxy` on PATH, else ~/.local/bin/oxy. */
28	+	export function findBinary(configured: string \| undefined): string {
29	+	if (configured && configured.trim()) {
30	+	return configured.trim();
31	+	}
32	+	const local = join(homedir(), ".local", "bin", "oxy");
33	+	return existsSync(local) ? local : "oxy";
34	+	}
35	+
36	+	export type Logger = (line: string) => void;
37	+
38	+	export class Oxy {
39	+	constructor(
40	+	public readonly binary: string,
41	+	private readonly logger: Logger = () => {},
42	+	) {}
43	+
44	+	/** Run oxy in `cwd`; resolves with the exit status, never rejects on a non-zero status. */
45	+	run(cwd: string, args: string[]): Promise<RunResult> {
46	+	const started = Date.now();
47	+	const full = ["--plain", ...args];
48	+	return new Promise((resolve, reject) => {
49	+	execFile(
50	+	this.binary,
51	+	full,
52	+	{ cwd, maxBuffer: 256 * 1024 * 1024, encoding: "buffer", env: { ...process.env, NO_COLOR: "1" } },
53	+	(error, stdout, stderr) => {
54	+	const err = stderr.toString("utf8");
55	+	const code = error && typeof (error as NodeJS.ErrnoException).code === "number" ? ((error as NodeJS.ErrnoException).code as unknown as number) : error ? -1 : 0;
56	+	this.logger(`oxy ${args.join(" ")} (${cwd}) → ${code} in ${Date.now() - started} ms${err.trim() ? `: ${err.trim()}` : ""}`);
57	+	if (error && (error as NodeJS.ErrnoException).code === "ENOENT") {
58	+	reject(new OxyError(full, -1, `oxy not found at ${this.binary}`));
59	+	return;
60	+	}
61	+	resolve({ code, stdout: stdout as Buffer, stderr: err });
62	+	},
63	+	);
64	+	});
65	+	}
66	+
67	+	/** Run and require success (exit 0, or one of `okCodes`). */
68	+	async check(cwd: string, args: string[], okCodes: number[] = [0]): Promise<RunResult> {
69	+	const r = await this.run(cwd, args);
70	+	if (!okCodes.includes(r.code)) {
71	+	throw new OxyError(args, r.code, r.stderr);
72	+	}
73	+	return r;
74	+	}
75	+
76	+	async json<T>(cwd: string, args: string[], okCodes: number[] = [0]): Promise<T> {
77	+	const r = await this.check(cwd, [...args, "--json"], okCodes);
78	+	const text = r.stdout.toString("utf8").trim();
79	+	try {
80	+	return JSON.parse(text) as T;
81	+	} catch (e) {
82	+	throw new OxyError(args, r.code, `oxy ${args.join(" ")} did not print JSON: ${text.slice(0, 200)}`);
83	+	}
84	+	}
85	+
86	+	// ---------------------------------------------------------------- commands
87	+
88	+	async version(): Promise<VersionInfo> {
89	+	return this.json<VersionInfo>(process.cwd(), ["version"]);
90	+	}
91	+
92	+	/** The repository containing `cwd`, or null when there is none. */
93	+	async root(cwd: string): Promise<RootInfo \| null> {
94	+	const r = await this.run(cwd, ["root", "--json"]);
95	+	if (r.code !== 0) {
96	+	return null;
97	+	}
98	+	const v = JSON.parse(r.stdout.toString("utf8"));
99	+	return v === null ? null : (v as RootInfo);
100	+	}
101	+
102	+	status(root: string): Promise<StatusInfo> {
103	+	return this.json<StatusInfo>(root, ["status"], [0, 2]);
104	+	}
105	+
106	+	async prompt(root: string, format?: string): Promise<string> {
107	+	const args = ["prompt", "--glyphs"];
108	+	if (format) {
109	+	args.push("--format", format);
110	+	}
111	+	const r = await this.run(root, args);
112	+	return r.code === 0 ? r.stdout.toString("utf8").trim() : "";
113	+	}
114	+
115	+	/** File content at a state; `change` may be a hash prefix, id prefix, bookmark, or tag. */
116	+	async cat(root: string, path: string, change?: string): Promise<Buffer> {
117	+	const args = ["cat", path];
118	+	if (change) {
119	+	args.push("-r", change);
120	+	}
121	+	return (await this.check(root, args)).stdout;
122	+	}
123	+
124	+	log(root: string, limit?: number, path?: string): Promise<LogInfo> {
125	+	const args = ["log"];
126	+	if (limit !== undefined) {
127	+	args.push("-n", String(limit));
128	+	}
129	+	if (path) {
130	+	args.push("--path", path);
131	+	}
132	+	return this.json<LogInfo>(root, args);
133	+	}
134	+
135	+	commit(root: string, message: string, paths: string[] = []): Promise<void> {
136	+	return this.check(root, ["commit", "-m", message, ...paths]).then(() => undefined);
137	+	}
138	+
139	+	bookmarks(root: string): Promise<BookmarkInfo[]> {
140	+	return this.json<BookmarkInfo[]>(root, ["bookmark", "list"]);
141	+	}
142	+	}
143	+
144	+	// ---------------------------------------------------------------- types
145	+
146	+	export interface VersionInfo {
147	+	version: string;
148	+	protocol: number;
149	+	format: number;
150	+	}
151	+
152	+	export interface RootInfo {
153	+	root: string;
154	+	workspace: string;
155	+	bookmark: string;
156	+	}
157	+
158	+	export type PathStatus = "Added" \| "Modified" \| "Removed" \| "Renamed" \| "ModeChanged" \| "ConflictEdited" \| "Resolved";
159	+
160	+	export interface StatusInfo {
161	+	bookmark: string;
162	+	working_copy: string;
163	+	heads: number;
164	+	clean: boolean;
165	+	conflicted: boolean;
166	+	paths: { path: string; status: PathStatus }[];
167	+	conflicts: ConflictInfo[];
168	+	}
169	+
170	+	export interface ConflictInfo {
171	+	kind: string;
172	+	path?: string;
173	+	node?: string;
174	+	nodes?: string[];
175	+	changes?: string[];
176	+	resolved?: boolean \| "markers";
177	+	}
178	+
179	+	export interface LogEntry {
180	+	hash: string;
181	+	change_id: string;
182	+	author: string;
183	+	author_key: string;
184	+	when_ms: number;
185	+	message: string;
186	+	kind: string;
187	+	deps: string[];
188	+	head: boolean;
189	+	working_copy: boolean;
190	+	signature: { status: string; key?: string; name?: string; revoked?: boolean; reason?: string } \| null;
191	+	}
192	+
193	+	export interface LogInfo {
194	+	bookmark: string;
195	+	total: number;
196	+	changes: LogEntry[];
197	+	}
198	+
199	+	export interface BookmarkInfo {
200	+	name: string;
201	+	heads: string[];
202	+	current: boolean;
203	+	ahead: number \| null;
204	+	behind: number \| null;
205	+	}

1	+	// One Oxygen repository as VS Code sees it: the source control provider,
2	+	// its resource groups, the status bar item, and the watchers that keep
3	+	// them fresh (spec §3, §5.1, §5.4).
4	+
5	+	import * as vscode from "vscode";
6	+	import { basename, join, relative } from "node:path";
7	+	import { Oxy, PathStatus, StatusInfo } from "./oxy";
8	+	import { baseUri } from "./contentProvider";
9	+
10	+	const STATUS_LETTER: Record<PathStatus, string> = {
11	+	Added: "A",
12	+	Modified: "M",
13	+	Removed: "D",
14	+	Renamed: "R",
15	+	ModeChanged: "X",
16	+	ConflictEdited: "‼",
17	+	Resolved: "✔",
18	+	};
19	+
20	+	const STATUS_WORD: Record<PathStatus, string> = {
21	+	Added: "added",
22	+	Modified: "modified",
23	+	Removed: "removed",
24	+	Renamed: "renamed",
25	+	ModeChanged: "mode changed",
26	+	ConflictEdited: "conflict markers remain",
27	+	Resolved: "conflict resolved",
28	+	};
29	+
30	+	const STATUS_COLOR: Record<PathStatus, string> = {
31	+	Added: "gitDecoration.addedResourceForeground",
32	+	Modified: "gitDecoration.modifiedResourceForeground",
33	+	Removed: "gitDecoration.deletedResourceForeground",
34	+	Renamed: "gitDecoration.renamedResourceForeground",
35	+	ModeChanged: "gitDecoration.modifiedResourceForeground",
36	+	ConflictEdited: "gitDecoration.conflictingResourceForeground",
37	+	Resolved: "gitDecoration.stageModifiedResourceForeground",
38	+	};
39	+
40	+	export class OxyResourceState implements vscode.SourceControlResourceState {
41	+	readonly resourceUri: vscode.Uri;
42	+	readonly decorations: vscode.SourceControlResourceDecorations;
43	+	readonly command: vscode.Command;
44	+
45	+	constructor(
46	+	readonly repository: Repository,
47	+	readonly path: string,
48	+	readonly status: PathStatus,
49	+	) {
50	+	this.resourceUri = vscode.Uri.file(join(repository.root, path));
51	+	this.decorations = {
52	+	strikeThrough: status === "Removed",
53	+	tooltip: STATUS_WORD[status],
54	+	faded: false,
55	+	};
56	+	this.command = { command: "oxygen.openChanges", title: "Open Changes", arguments: [this] };
57	+	}
58	+
59	+	get letter(): string {
60	+	return STATUS_LETTER[this.status];
61	+	}
62	+
63	+	get color(): vscode.ThemeColor {
64	+	return new vscode.ThemeColor(STATUS_COLOR[this.status]);
65	+	}
66	+	}
67	+
68	+	export class Repository implements vscode.Disposable, vscode.QuickDiffProvider {
69	+	readonly sourceControl: vscode.SourceControl;
70	+	readonly conflictsGroup: vscode.SourceControlResourceGroup;
71	+	readonly changesGroup: vscode.SourceControlResourceGroup;
72	+	private readonly statusBar: vscode.StatusBarItem;
73	+	private readonly disposables: vscode.Disposable[] = [];
74	+	private readonly onDidChangeStatusEmitter = new vscode.EventEmitter<StatusInfo>();
75	+	readonly onDidChangeStatus = this.onDidChangeStatusEmitter.event;
76	+	private latest: StatusInfo \| undefined;
77	+	private refreshTimer: NodeJS.Timeout \| undefined;
78	+	private refreshing: Promise<void> \| undefined;
79	+	private refreshAgain = false;
80	+
81	+	constructor(
82	+	readonly oxy: Oxy,
83	+	readonly root: string,
84	+	readonly workspaceFolder: vscode.WorkspaceFolder \| undefined,
85	+	) {
86	+	const rootUri = vscode.Uri.file(root);
87	+	this.sourceControl = vscode.scm.createSourceControl("oxygen", `Oxygen (${basename(root)})`, rootUri);
88	+	this.sourceControl.quickDiffProvider = this;
89	+	this.sourceControl.acceptInputCommand = { command: "oxygen.commit", title: "Commit", arguments: [this] };
90	+	this.sourceControl.inputBox.placeholder = "Message (Ctrl+Enter to commit)";
91	+	this.conflictsGroup = this.sourceControl.createResourceGroup("conflicts", "Conflicts");
92	+	this.conflictsGroup.hideWhenEmpty = true;
93	+	this.changesGroup = this.sourceControl.createResourceGroup("changes", "Changes");
94	+	this.statusBar = vscode.window.createStatusBarItem("oxygen.status", vscode.StatusBarAlignment.Left, 100);
95	+	this.statusBar.name = "Oxygen";
96	+	this.statusBar.command = "oxygen.showLog";
97	+	this.disposables.push(this.sourceControl, this.conflictsGroup, this.changesGroup, this.statusBar, this.onDidChangeStatusEmitter);
98	+
99	+	if (vscode.workspace.getConfiguration("oxygen").get<boolean>("autoRefresh", true)) {
100	+	// Files in the workspace, except the repository's own store.
101	+	const files = vscode.workspace.createFileSystemWatcher(new vscode.RelativePattern(rootUri, "*/"));
102	+	const onFile = (uri: vscode.Uri) => {
103	+	if (!uri.fsPath.startsWith(join(root, ".oxy"))) {
104	+	this.scheduleRefresh();
105	+	}
106	+	};
107	+	files.onDidChange(onFile, this, this.disposables);
108	+	files.onDidCreate(onFile, this, this.disposables);
109	+	files.onDidDelete(onFile, this, this.disposables);
110	+	this.disposables.push(files);
111	+	// Any operation, including ones run from a terminal, moves the op head.
112	+	const ops = vscode.workspace.createFileSystemWatcher(new vscode.RelativePattern(rootUri, ".oxy/ops/head"));
113	+	ops.onDidChange(() => this.scheduleRefresh(), this, this.disposables);
114	+	ops.onDidCreate(() => this.scheduleRefresh(), this, this.disposables);
115	+	this.disposables.push(ops);
116	+	}
117	+	vscode.window.onDidChangeWindowState((s) => s.focused && this.scheduleRefresh(), this, this.disposables);
118	+	}
119	+
120	+	get status(): StatusInfo \| undefined {
121	+	return this.latest;
122	+	}
123	+
124	+	/** The repository-relative path of a file under this root, or undefined. */
125	+	relativePath(uri: vscode.Uri): string \| undefined {
126	+	if (uri.scheme !== "file") {
127	+	return undefined;
128	+	}
129	+	const rel = relative(this.root, uri.fsPath);
130	+	if (!rel \|\| rel.startsWith("..") \|\| rel.startsWith(".oxy")) {
131	+	return undefined;
132	+	}
133	+	return rel.split("\\").join("/");
134	+	}
135	+
136	+	scheduleRefresh(): void {
137	+	if (this.refreshTimer) {
138	+	clearTimeout(this.refreshTimer);
139	+	}
140	+	this.refreshTimer = setTimeout(() => void this.refresh(), 250);
141	+	}
142	+
143	+	/** Refresh now; a refresh requested during one runs once more afterwards. */
144	+	refresh(): Promise<void> {
145	+	if (this.refreshing) {
146	+	this.refreshAgain = true;
147	+	return this.refreshing;
148	+	}
149	+	this.refreshing = this.doRefresh().finally(() => {
150	+	this.refreshing = undefined;
151	+	if (this.refreshAgain) {
152	+	this.refreshAgain = false;
153	+	void this.refresh();
154	+	}
155	+	});
156	+	return this.refreshing;
157	+	}
158	+
159	+	private async doRefresh(): Promise<void> {
160	+	try {
161	+	const [status, prompt] = await Promise.all([this.oxy.status(this.root), this.oxy.prompt(this.root)]);
162	+	this.latest = status;
163	+	const conflicted = new Set(status.conflicts.map((c) => c.path).filter((p): p is string => !!p));
164	+	const conflicts: OxyResourceState[] = [];
165	+	const changes: OxyResourceState[] = [];
166	+	for (const p of status.paths) {
167	+	const state = new OxyResourceState(this, p.path, p.status);
168	+	if (p.status === "ConflictEdited" \|\| p.status === "Resolved" \|\| conflicted.has(p.path)) {
169	+	conflicts.push(state);
170	+	} else {
171	+	changes.push(state);
172	+	}
173	+	}
174	+	// Conflicted files the working copy has not touched yet still need resolving.
175	+	for (const c of status.conflicts) {
176	+	if (c.path && !status.paths.some((p) => p.path === c.path)) {
177	+	conflicts.push(new OxyResourceState(this, c.path, "ConflictEdited"));
178	+	}
179	+	}
180	+	this.conflictsGroup.resourceStates = conflicts;
181	+	this.changesGroup.resourceStates = changes;
182	+	this.sourceControl.count = status.paths.length + (status.conflicts.length ? status.conflicts.length : 0);
183	+	this.updateStatusBar(status, prompt);
184	+	this.onDidChangeStatusEmitter.fire(status);
185	+	} catch (e) {
186	+	this.statusBar.text = "$(warning) oxy";
187	+	this.statusBar.tooltip = String(e);
188	+	this.statusBar.show();
189	+	}
190	+	}
191	+
192	+	private updateStatusBar(status: StatusInfo, prompt: string): void {
193	+	if (!vscode.workspace.getConfiguration("oxygen").get<boolean>("statusBar.enabled", true)) {
194	+	this.statusBar.hide();
195	+	return;
196	+	}
197	+	const text = prompt \|\| `${status.bookmark} ${status.working_copy.slice(0, 8)}`;
198	+	this.statusBar.text = text;
199	+	this.statusBar.tooltip = new vscode.MarkdownString(
200	+	`Oxygen ${basename(this.root)}\n\n` +
201	+	`Bookmark \`${status.bookmark}\` with ${status.heads} head${status.heads === 1 ? "" : "s"}\n\n` +
202	+	(status.conflicted ? `$(warning) The state has conflicts\n\n` : "") +
203	+	`${status.paths.length} changed path${status.paths.length === 1 ? "" : "s"}`,
204	+	true,
205	+	);
206	+	this.statusBar.backgroundColor = status.conflicted ? new vscode.ThemeColor("statusBarItem.errorBackground") : undefined;
207	+	this.statusBar.show();
208	+	}
209	+
210	+	// QuickDiffProvider: the base version of a file, served from oxy.
211	+	provideOriginalResource(uri: vscode.Uri): vscode.Uri \| undefined {
212	+	const rel = this.relativePath(uri);
213	+	if (!rel) {
214	+	return undefined;
215	+	}
216	+	const status = this.latest?.paths.find((p) => p.path === rel)?.status;
217	+	if (status === "Added") {
218	+	return undefined;
219	+	}
220	+	return baseUri(this.root, rel);
221	+	}
222	+
223	+	dispose(): void {
224	+	if (this.refreshTimer) {
225	+	clearTimeout(this.refreshTimer);
226	+	}
227	+	for (const d of this.disposables) {
228	+	d.dispose();
229	+	}
230	+	}
231	+	}

1	+	// The process wrapper against the real oxy binary on a scratch repository.
2	+	// Runs with `npm test`; needs oxy on PATH, at ~/.local/bin/oxy, or in OXY_BIN.
3	+
4	+	import { test } from "node:test";
5	+	import assert from "node:assert/strict";
6	+	import { mkdtempSync, writeFileSync, mkdirSync } from "node:fs";
7	+	import { tmpdir } from "node:os";
8	+	import { join } from "node:path";
9	+	import { Oxy, findBinary } from "../out/oxy.mjs";
10	+
11	+	const binary = process.env.OXY_BIN ?? findBinary(undefined);
12	+	const oxy = new Oxy(binary);
13	+
14	+	test("root, status, cat, log and commit round trip", async () => {
15	+	const dir = mkdtempSync(join(tmpdir(), "oxy-vscode-"));
16	+	const home = join(dir, "home");
17	+	mkdirSync(home);
18	+	process.env.OXY_HOME = home;
19	+	await oxy.check(dir, ["init", "repo"]);
20	+	const root = join(dir, "repo");
21	+	await oxy.check(root, ["identity", "create", "--name", "Test", "--email", "[email protected]"]);
22	+
23	+	const version = await oxy.version();
24	+	assert.equal(version.protocol, 1);
25	+	assert.equal(await oxy.root(dir), null, "outside a repository");
26	+	const info = await oxy.root(root);
27	+	assert.equal(info?.bookmark, "main");
28	+	assert.ok(info?.root.endsWith("repo"));
29	+
30	+	writeFileSync(join(root, "a.txt"), "one\n");
31	+	let status = await oxy.status(root);
32	+	assert.deepEqual(status.paths, [{ path: "a.txt", status: "Added" }]);
33	+	assert.equal(status.clean, false);
34	+	await oxy.commit(root, "first");
35	+	status = await oxy.status(root);
36	+	assert.equal(status.clean, true);
37	+
38	+	writeFileSync(join(root, "a.txt"), "one\ntwo\n");
39	+	assert.equal((await oxy.cat(root, "a.txt")).toString(), "one\n", "the base version");
40	+	const log = await oxy.log(root, 10);
41	+	assert.equal(log.changes.filter((c) => !c.working_copy).length, 1);
42	+	assert.equal(log.changes.find((c) => !c.working_copy)?.signature?.status, "unsigned");
43	+	assert.ok((await oxy.prompt(root)).includes("main"));
44	+	const bookmarks = await oxy.bookmarks(root);
45	+	assert.deepEqual(bookmarks.map((b) => [b.name, b.current]), [["main", true]]);
46	+	await assert.rejects(oxy.cat(root, "missing.txt"), /not in that state/);
47	+	});

1	+	{
2	+	"compilerOptions": {
3	+	"target": "ES2022",
4	+	"module": "Node16",
5	+	"moduleResolution": "Node16",
6	+	"lib": ["ES2022"],
7	+	"strict": true,
8	+	"noImplicitReturns": true,
9	+	"noUnusedLocals": true,
10	+	"noFallthroughCasesInSwitch": true,
11	+	"esModuleInterop": true,
12	+	"skipLibCheck": true,
13	+	"sourceMap": true,
14	+	"outDir": "out",
15	+	"rootDir": "src"
16	+	},
17	+	"include": ["src"]
18	+	}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1	+	{
2	+	"name": "oxygen-vscode",
3	+	"version": "0.1.0",
4	+	"lockfileVersion": 3,
5	+	"requires": true,
6	+	"packages": {
7	+	"": {
8	+	"name": "oxygen-vscode",
9	+	"version": "0.1.0",
10	+	"license": "MIT OR Apache-2.0",
11	+	"devDependencies": {
12	+	"@types/node": "^24.0.0",
13	+	"@types/vscode": "^1.137.0",
14	+	"@vscode/vsce": "^4.0.0",
15	+	"esbuild": "^0.28.0",
16	+	"typescript": "^5.9.0"
17	+	},
18	+	"engines": {
19	+	"vscode": "^1.137.0"
20	+	}
21	+	},
22	+	"node_modules/@azure/abort-controller": {
23	+	"version": "2.2.0",
24	+	"resolved": "https://registry.npmjs.org/@azure/abort-controller/-/abort-controller-2.2.0.tgz",
25	+	"integrity": "sha512-fNAjWnA/nZ2jz31kxR/AqRaUT8ewHBw/WuBIosK0moMy1C9e5ValbDfFdIxJzVOOYaYkV/b2F1S4H/aHiqfVQg==",
26	+	"dev": true,
27	+	"license": "MIT",
28	+	"dependencies": {
29	+	"tslib": "^2.6.2"
30	+	},
31	+	"engines": {
32	+	"node": ">=22.0.0"
33	+	}
34	+	},
35	+	"node_modules/@azure/core-auth": {
36	+	"version": "1.11.0",
37	+	"resolved": "https://registry.npmjs.org/@azure/core-auth/-/core-auth-1.11.0.tgz",
38	+	"integrity": "sha512-IUZydyTUkDnYdstOW9pFOOUQlBjAepK5teihDE3x6yxsPJs/hsAaaYpeGxdxrgtOiJbBKSjKW7MDk7AEhb4LRg==",
39	+	"dev": true,
40	+	"license": "MIT",

Milestone 0.1: source control view, diffs over the oxy: scheme, quick diff, decorations, status bar, commit, quick-pick log; process wrapper with a Node test; packaging bed495a96408

Keyboard