Added nono profiles & orca integration - Added some extensions to start working on
This commit is contained in:
@@ -0,0 +1,443 @@
|
||||
import { NodeServices } from "@effect/platform-node";
|
||||
import { assert, it } from "@effect/vitest";
|
||||
import { homedir } from "node:os";
|
||||
import { dirname, join } from "node:path";
|
||||
import { Effect, FileSystem } from "effect";
|
||||
import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
|
||||
import {
|
||||
buildFdArgs,
|
||||
buildRgArgs,
|
||||
FD_DEFAULT_LIMIT,
|
||||
normalizeSearchPath,
|
||||
} from "./src/args.ts";
|
||||
import {
|
||||
FD_INTEL_DARWIN_VERSION,
|
||||
InstallError,
|
||||
readBoundedResponse,
|
||||
releaseAsset,
|
||||
resolveBinary,
|
||||
TOOL_SPECS,
|
||||
UnsupportedPlatformError,
|
||||
type BinaryEnv,
|
||||
type ReleaseAsset,
|
||||
type ResolvedBinary,
|
||||
} from "./src/binaries.ts";
|
||||
import { formatCapturedOutput, formatOutput } from "./src/output.ts";
|
||||
import { executeSearchProcess } from "./src/process.ts";
|
||||
import { installNotifications, makeBinaryInitializers } from "./index.ts";
|
||||
|
||||
// --- argument construction -------------------------------------------------
|
||||
|
||||
it("fd args: defaults list everything with the default limit", () => {
|
||||
assert.deepEqual(buildFdArgs({}), [
|
||||
"--color=never",
|
||||
"--max-results",
|
||||
String(FD_DEFAULT_LIMIT),
|
||||
"--",
|
||||
"",
|
||||
]);
|
||||
});
|
||||
|
||||
it("fd args: all options are translated and pattern stays behind --", () => {
|
||||
const args = buildFdArgs({
|
||||
pattern: "-rf",
|
||||
path: "@src",
|
||||
type: "file",
|
||||
extension: ".ts",
|
||||
glob: true,
|
||||
hidden: true,
|
||||
max_depth: 3,
|
||||
limit: 50,
|
||||
});
|
||||
assert.deepEqual(args, [
|
||||
"--color=never",
|
||||
"--hidden",
|
||||
"--glob",
|
||||
"--type",
|
||||
"f",
|
||||
"--extension",
|
||||
"ts",
|
||||
"--max-depth",
|
||||
"3",
|
||||
"--max-results",
|
||||
"50",
|
||||
"--",
|
||||
"-rf",
|
||||
"src",
|
||||
]);
|
||||
});
|
||||
|
||||
it("fd args: out-of-range values are clamped", () => {
|
||||
const args = buildFdArgs({ max_depth: 500, limit: 1_000_000 });
|
||||
assert.deepEqual(args, [
|
||||
"--color=never",
|
||||
"--max-depth",
|
||||
"64",
|
||||
"--max-results",
|
||||
"10000",
|
||||
"--",
|
||||
"",
|
||||
]);
|
||||
});
|
||||
|
||||
it("rg args: defaults use smart-case and safe separators", () => {
|
||||
assert.deepEqual(buildRgArgs({ pattern: "--help" }), [
|
||||
"--line-number",
|
||||
"--color=never",
|
||||
"--no-heading",
|
||||
"--with-filename",
|
||||
"--smart-case",
|
||||
"--max-count",
|
||||
"100",
|
||||
"--",
|
||||
"--help",
|
||||
]);
|
||||
});
|
||||
|
||||
it("rg args: all options are translated", () => {
|
||||
const args = buildRgArgs({
|
||||
pattern: "TODO",
|
||||
path: "@lib",
|
||||
glob: "*.ts",
|
||||
file_type: "ts",
|
||||
case_sensitive: true,
|
||||
fixed_strings: true,
|
||||
hidden: true,
|
||||
context: 2,
|
||||
limit: 10,
|
||||
});
|
||||
assert.deepEqual(args, [
|
||||
"--line-number",
|
||||
"--color=never",
|
||||
"--no-heading",
|
||||
"--with-filename",
|
||||
"--case-sensitive",
|
||||
"--fixed-strings",
|
||||
"--hidden",
|
||||
"--context",
|
||||
"2",
|
||||
"--glob",
|
||||
"*.ts",
|
||||
"--type",
|
||||
"ts",
|
||||
"--max-count",
|
||||
"10",
|
||||
"--",
|
||||
"TODO",
|
||||
"lib",
|
||||
]);
|
||||
});
|
||||
|
||||
it("rg args: case_sensitive false forces ignore-case", () => {
|
||||
const args = buildRgArgs({ pattern: "x", case_sensitive: false });
|
||||
assert.isTrue(args.includes("--ignore-case"));
|
||||
assert.isFalse(args.includes("--smart-case"));
|
||||
});
|
||||
|
||||
it("path normalization strips leading @ and expands ~", () => {
|
||||
assert.equal(normalizeSearchPath("@src/lib"), "src/lib");
|
||||
assert.equal(normalizeSearchPath("~"), homedir());
|
||||
assert.equal(normalizeSearchPath("~/projects"), join(homedir(), "projects"));
|
||||
assert.equal(normalizeSearchPath(" plain "), "plain");
|
||||
});
|
||||
|
||||
// --- binary resolution -----------------------------------------------------
|
||||
|
||||
function makeEnv(options: {
|
||||
available?: string[];
|
||||
installShouldFail?: boolean;
|
||||
}): BinaryEnv & { installs: ReleaseAsset[]; probes: string[] } {
|
||||
const installs: ReleaseAsset[] = [];
|
||||
const probes: string[] = [];
|
||||
const installed = new Set<string>();
|
||||
return {
|
||||
installs,
|
||||
probes,
|
||||
probe: (command) =>
|
||||
Effect.sync(() => {
|
||||
probes.push(command);
|
||||
return (
|
||||
(options.available ?? []).includes(command) || installed.has(command)
|
||||
);
|
||||
}),
|
||||
install: (asset, destination) => {
|
||||
if (options.installShouldFail) {
|
||||
return Effect.fail(new InstallError({ message: "network down" }));
|
||||
}
|
||||
return Effect.sync(() => {
|
||||
installs.push(asset);
|
||||
installed.add(destination);
|
||||
});
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
const darwinArm = { os: "darwin", arch: "arm64" } as const;
|
||||
|
||||
it.effect("binary resolution: system fd wins and nothing is installed", () =>
|
||||
Effect.gen(function* () {
|
||||
const env = makeEnv({ available: ["fd"] });
|
||||
const resolved = yield* resolveBinary(
|
||||
TOOL_SPECS.fd,
|
||||
"/repo/bin",
|
||||
darwinArm,
|
||||
env,
|
||||
);
|
||||
|
||||
assert.deepEqual(resolved, {
|
||||
tool: "fd",
|
||||
command: "fd",
|
||||
source: "system",
|
||||
});
|
||||
assert.equal(env.installs.length, 0);
|
||||
}),
|
||||
);
|
||||
|
||||
it.effect("binary resolution: fdfind is accepted as a system fd", () =>
|
||||
Effect.gen(function* () {
|
||||
const env = makeEnv({ available: ["fdfind"] });
|
||||
const resolved = yield* resolveBinary(
|
||||
TOOL_SPECS.fd,
|
||||
"/repo/bin",
|
||||
darwinArm,
|
||||
env,
|
||||
);
|
||||
|
||||
assert.deepEqual(resolved, {
|
||||
tool: "fd",
|
||||
command: "fdfind",
|
||||
source: "system",
|
||||
});
|
||||
assert.equal(env.installs.length, 0);
|
||||
}),
|
||||
);
|
||||
|
||||
it.effect("binary resolution: existing bin fallback is used silently", () =>
|
||||
Effect.gen(function* () {
|
||||
const env = makeEnv({ available: ["/repo/bin/rg"] });
|
||||
const resolved = yield* resolveBinary(
|
||||
TOOL_SPECS.rg,
|
||||
"/repo/bin",
|
||||
darwinArm,
|
||||
env,
|
||||
);
|
||||
|
||||
assert.deepEqual(resolved, {
|
||||
tool: "rg",
|
||||
command: "/repo/bin/rg",
|
||||
source: "bundled",
|
||||
});
|
||||
assert.equal(env.installs.length, 0);
|
||||
}),
|
||||
);
|
||||
|
||||
it.effect(
|
||||
"binary resolution: missing everywhere triggers exactly one install",
|
||||
() =>
|
||||
Effect.gen(function* () {
|
||||
const env = makeEnv({ available: [] });
|
||||
const resolved = yield* resolveBinary(
|
||||
TOOL_SPECS.rg,
|
||||
"/repo/bin",
|
||||
darwinArm,
|
||||
env,
|
||||
);
|
||||
|
||||
assert.equal(resolved.source, "installed");
|
||||
assert.equal(resolved.command, "/repo/bin/rg");
|
||||
assert.equal(env.installs.length, 1);
|
||||
assert.match(
|
||||
env.installs[0].url,
|
||||
/^https:\/\/github\.com\/BurntSushi\/ripgrep\//,
|
||||
);
|
||||
}),
|
||||
);
|
||||
|
||||
it.effect("binary resolution: install failure surfaces a typed error", () =>
|
||||
Effect.gen(function* () {
|
||||
const env = makeEnv({ available: [], installShouldFail: true });
|
||||
const error = yield* Effect.flip(
|
||||
resolveBinary(TOOL_SPECS.fd, "/repo/bin", darwinArm, env),
|
||||
);
|
||||
|
||||
assert.instanceOf(error, InstallError);
|
||||
assert.equal(error.message, "network down");
|
||||
}),
|
||||
);
|
||||
|
||||
it.effect(
|
||||
"binary resolution: unsupported platform fails without installing",
|
||||
() =>
|
||||
Effect.gen(function* () {
|
||||
const env = makeEnv({ available: [] });
|
||||
const error = yield* Effect.flip(
|
||||
resolveBinary(
|
||||
TOOL_SPECS.fd,
|
||||
"/repo/bin",
|
||||
{ os: "linux", arch: "s390x" },
|
||||
env,
|
||||
),
|
||||
);
|
||||
|
||||
assert.instanceOf(error, UnsupportedPlatformError);
|
||||
assert.equal(env.installs.length, 0);
|
||||
}),
|
||||
);
|
||||
|
||||
it.effect("binary resolution: one failed tool does not disable the other", () =>
|
||||
Effect.gen(function* () {
|
||||
const env = makeEnv({
|
||||
available: ["rg"],
|
||||
installShouldFail: true,
|
||||
});
|
||||
const initializers = makeBinaryInitializers("/repo/bin", darwinArm, env);
|
||||
|
||||
const fdError = yield* Effect.flip(initializers.fd);
|
||||
const rg = yield* initializers.rg;
|
||||
|
||||
assert.instanceOf(fdError, InstallError);
|
||||
assert.deepEqual(rg, { tool: "rg", command: "rg", source: "system" });
|
||||
}),
|
||||
);
|
||||
|
||||
it("release assets cover macOS and Linux on arm64 and x64 over HTTPS", () => {
|
||||
for (const os of ["darwin", "linux"] as const) {
|
||||
for (const arch of ["arm64", "x64"] as const) {
|
||||
for (const tool of ["fd", "rg"] as const) {
|
||||
const asset = releaseAsset(tool, { os, arch });
|
||||
assert.isDefined(asset, `${tool} ${os}/${arch}`);
|
||||
assert.match(asset.url, /^https:\/\//);
|
||||
assert.isTrue(asset.url.endsWith(asset.fileName));
|
||||
assert.match(asset.sha256, /^[a-f0-9]{64}$/);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it("linux assets use statically linked musl builds", () => {
|
||||
const asset = releaseAsset("fd", { os: "linux", arch: "x64" });
|
||||
assert.isTrue(asset?.url.includes("unknown-linux-musl"));
|
||||
});
|
||||
|
||||
it("Intel macOS uses the latest fd release that publishes that target", () => {
|
||||
const asset = releaseAsset("fd", { os: "darwin", arch: "x64" });
|
||||
assert.equal(asset?.version, FD_INTEL_DARWIN_VERSION);
|
||||
});
|
||||
|
||||
it.effect(
|
||||
"bounded downloads reject oversized declared and streamed bodies",
|
||||
() =>
|
||||
Effect.gen(function* () {
|
||||
const request = HttpClientRequest.get(
|
||||
"https://example.com/archive.tar.gz",
|
||||
);
|
||||
const declared = HttpClientResponse.fromWeb(
|
||||
request,
|
||||
new Response("small", {
|
||||
headers: { "content-length": "100" },
|
||||
}),
|
||||
);
|
||||
const declaredError = yield* Effect.flip(
|
||||
readBoundedResponse(declared, 10),
|
||||
);
|
||||
assert.match(declaredError.message, /size limit/);
|
||||
|
||||
const streamed = HttpClientResponse.fromWeb(
|
||||
request,
|
||||
new Response("this body is too large"),
|
||||
);
|
||||
const streamedError = yield* Effect.flip(
|
||||
readBoundedResponse(streamed, 5),
|
||||
);
|
||||
assert.match(streamedError.message, /size limit/);
|
||||
}),
|
||||
);
|
||||
|
||||
// --- notification policy ----------------------------------------------------
|
||||
|
||||
it("notifications: only fresh installs notify", () => {
|
||||
const system: ResolvedBinary = {
|
||||
tool: "fd",
|
||||
command: "fd",
|
||||
source: "system",
|
||||
};
|
||||
const bundled: ResolvedBinary = {
|
||||
tool: "rg",
|
||||
command: "/repo/bin/rg",
|
||||
source: "bundled",
|
||||
};
|
||||
const installed: ResolvedBinary = {
|
||||
tool: "rg",
|
||||
command: "/repo/bin/rg",
|
||||
source: "installed",
|
||||
version: "15.2.0",
|
||||
};
|
||||
|
||||
assert.deepEqual(installNotifications([system, bundled]), []);
|
||||
const messages = installNotifications([system, installed]);
|
||||
assert.equal(messages.length, 1);
|
||||
assert.match(messages[0], /downloaded rg 15\.2\.0/);
|
||||
});
|
||||
|
||||
// --- output truncation -------------------------------------------------------
|
||||
|
||||
it.effect("process output is streamed to a complete spill file", () =>
|
||||
Effect.gen(function* () {
|
||||
const result = yield* executeSearchProcess({
|
||||
command: process.execPath,
|
||||
args: ["-e", 'process.stdout.write("line\\n".repeat(3000))'],
|
||||
cwd: process.cwd(),
|
||||
tempPrefix: "pi-search-test-",
|
||||
});
|
||||
const formatted = formatCapturedOutput(result.output);
|
||||
|
||||
assert.equal(result.code, 0);
|
||||
assert.isTrue(formatted.truncated);
|
||||
assert.equal(formatted.lineCount, 3000);
|
||||
assert.match(formatted.text, /2000 of 3000 lines/);
|
||||
assert.isDefined(formatted.fullOutputPath);
|
||||
|
||||
const fs = yield* FileSystem.FileSystem;
|
||||
const fullOutput = yield* fs.readFileString(formatted.fullOutputPath);
|
||||
assert.equal(fullOutput, "line\n".repeat(3000));
|
||||
yield* fs.remove(dirname(formatted.fullOutputPath), {
|
||||
recursive: true,
|
||||
force: true,
|
||||
});
|
||||
}).pipe(Effect.provide(NodeServices.layer)),
|
||||
);
|
||||
|
||||
it("output: small results pass through untouched", async () => {
|
||||
const formatted = await formatOutput("a.ts\nb.ts\n", {
|
||||
tempPrefix: "pi-fd-",
|
||||
persistFullOutput: () => Promise.reject(new Error("should not persist")),
|
||||
});
|
||||
assert.equal(formatted.text, "a.ts\nb.ts");
|
||||
assert.equal(formatted.lineCount, 2);
|
||||
assert.isFalse(formatted.truncated);
|
||||
assert.isUndefined(formatted.fullOutputPath);
|
||||
});
|
||||
|
||||
it("output: oversized results are truncated and persisted", async () => {
|
||||
const bigOutput = Array.from({ length: 3000 }, (_, i) => `file-${i}.ts`).join(
|
||||
"\n",
|
||||
);
|
||||
let persisted: string | undefined;
|
||||
const formatted = await formatOutput(bigOutput, {
|
||||
tempPrefix: "pi-fd-",
|
||||
persistFullOutput: async (full) => {
|
||||
persisted = full;
|
||||
return "/tmp/fake/output.txt";
|
||||
},
|
||||
});
|
||||
assert.isTrue(formatted.truncated);
|
||||
assert.equal(formatted.fullOutputPath, "/tmp/fake/output.txt");
|
||||
assert.equal(persisted, bigOutput);
|
||||
assert.match(formatted.text, /\[Output truncated: 2000 of 3000 lines/);
|
||||
assert.match(
|
||||
formatted.text,
|
||||
/Full output saved to: \/tmp\/fake\/output\.txt\]/,
|
||||
);
|
||||
const shownLines = formatted.text.split("\n");
|
||||
assert.equal(shownLines[0], "file-0.ts");
|
||||
});
|
||||
Reference in New Issue
Block a user