@mrclrchtr/supi-code-intelligence 11.4.0 → 12.0.0
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/CHANGELOG.md +22 -0
- package/README.md +13 -7
- package/node_modules/@mrclrchtr/supi-code-runtime/package.json +1 -1
- package/node_modules/@mrclrchtr/supi-code-runtime/src/api.ts +1 -0
- package/node_modules/@mrclrchtr/supi-code-runtime/src/types.ts +51 -23
- package/node_modules/@mrclrchtr/supi-core/package.json +1 -1
- package/node_modules/@mrclrchtr/supi-lsp/README.md +21 -16
- package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-code-runtime/package.json +1 -1
- package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-code-runtime/src/api.ts +1 -0
- package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-code-runtime/src/types.ts +51 -23
- package/node_modules/@mrclrchtr/supi-lsp/node_modules/@mrclrchtr/supi-core/package.json +1 -1
- package/node_modules/@mrclrchtr/supi-lsp/package.json +3 -3
- package/node_modules/@mrclrchtr/supi-lsp/src/api.ts +2 -2
- package/node_modules/@mrclrchtr/supi-lsp/src/client/client-diagnostic-capabilities.ts +13 -3
- package/node_modules/@mrclrchtr/supi-lsp/src/client/client-diagnostics.ts +25 -9
- package/node_modules/@mrclrchtr/supi-lsp/src/client/client-document-sync.ts +7 -5
- package/node_modules/@mrclrchtr/supi-lsp/src/client/client-edit-capture.ts +258 -0
- package/node_modules/@mrclrchtr/supi-lsp/src/client/client.ts +64 -11
- package/node_modules/@mrclrchtr/supi-lsp/src/config/capabilities.ts +8 -0
- package/node_modules/@mrclrchtr/supi-lsp/src/config/operation-support.ts +48 -79
- package/node_modules/@mrclrchtr/supi-lsp/src/manager/manager.ts +3 -1
- package/node_modules/@mrclrchtr/supi-lsp/src/provider/lsp-refactor-provider.ts +21 -35
- package/node_modules/@mrclrchtr/supi-lsp/src/provider/refactor-command-capture.ts +139 -0
- package/node_modules/@mrclrchtr/supi-lsp/src/provider/refactor-planning.ts +202 -47
- package/node_modules/@mrclrchtr/supi-lsp/src/session/route-boundary.ts +26 -0
- package/node_modules/@mrclrchtr/supi-lsp/src/session/runtime-registry.ts +57 -12
- package/node_modules/@mrclrchtr/supi-lsp/src/session/runtime-rename.ts +3 -0
- package/node_modules/@mrclrchtr/supi-lsp/src/session/workspace-lsp-runtime.ts +22 -1
- package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/package.json +1 -1
- package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/src/api.ts +1 -0
- package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-code-runtime/src/types.ts +51 -23
- package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-core/package.json +1 -1
- package/node_modules/@mrclrchtr/supi-tree-sitter/package.json +3 -3
- package/node_modules/@mrclrchtr/supi-tree-sitter/src/coordinates.ts +16 -2
- package/node_modules/@mrclrchtr/supi-tree-sitter/src/session/structural-worker-client.ts +3 -2
- package/node_modules/@mrclrchtr/supi-tree-sitter/src/syntax-errors.ts +2 -0
- package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/call-range.ts +94 -0
- package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/call-sites.ts +26 -6
- package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/callees.ts +6 -3
- package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/exports.ts +13 -4
- package/node_modules/@mrclrchtr/supi-tree-sitter/src/worker/runtime.ts +1 -9
- package/package.json +5 -5
- package/src/analysis/health/server-status.ts +41 -12
- package/src/analysis/target/anchored-structural.ts +4 -1
- package/src/analysis/target/symbol.ts +1 -1
- package/src/session/find-types.ts +8 -4
- package/src/session/find-workflow.ts +11 -16
- package/src/session/input/health-refactor.ts +48 -34
- package/src/session/input/workflows.ts +45 -46
- package/src/session/inspect/file-point.ts +2 -2
- package/src/session/inspect-types.ts +1 -1
- package/src/session/inspect-workflow.ts +3 -3
- package/src/session/refactor-file-actions.ts +122 -0
- package/src/session/refactor-plan-pipeline.ts +152 -0
- package/src/session/refactor-plans.ts +18 -15
- package/src/session/refactor-types.ts +24 -12
- package/src/session/refactor-workflow.ts +68 -243
- package/src/tool/code_find/execute.ts +6 -7
- package/src/tool/code_find/spec.ts +9 -16
- package/src/tool/code_find/tui.ts +12 -6
- package/src/tool/code_graph/spec.ts +6 -0
- package/src/tool/code_health/spec.ts +6 -0
- package/src/tool/code_health/structured-schema.ts +4 -4
- package/src/tool/code_health/structured.ts +15 -17
- package/src/tool/code_inspect/execute.ts +1 -1
- package/src/tool/code_inspect/markdown.ts +33 -6
- package/src/tool/code_inspect/result.ts +1 -1
- package/src/tool/code_inspect/spec.ts +14 -6
- package/src/tool/code_inspect/structured.ts +2 -2
- package/src/tool/code_inspect/tui.ts +2 -2
- package/src/tool/code_orientation/spec.ts +8 -0
- package/src/tool/code_refactor_apply/result.ts +2 -1
- package/src/tool/code_refactor_apply/spec.ts +7 -0
- package/src/tool/code_refactor_plan/execute.ts +0 -2
- package/src/tool/code_refactor_plan/result.ts +23 -13
- package/src/tool/code_refactor_plan/spec.ts +8 -2
- package/src/tool/code_refactor_plan/structured.ts +59 -12
- package/src/tool/code_refactor_plan/tui.ts +14 -17
- package/src/tool/code_resolve/markdown.ts +1 -1
- package/src/tool/code_resolve/spec.ts +6 -0
- package/src/tool/namespace.ts +14 -0
- package/src/tool/refactor-markdown.ts +55 -15
- package/src/tool/register.ts +3 -0
- package/src/tool/result/refactor-preview.ts +118 -0
- package/src/tool/result/refactor-unavailable.ts +16 -0
- package/src/tool/result/refactor.ts +8 -2
- package/src/tool/schemas.ts +63 -20
- package/src/tool/specs.ts +3 -0
- package/src/ui/status-overlay.ts +1 -1
|
@@ -7,10 +7,10 @@ import type {
|
|
|
7
7
|
import type { WorkspaceLspRuntime } from "../session/runtime-registry.ts";
|
|
8
8
|
import {
|
|
9
9
|
collectCodeActionResults,
|
|
10
|
-
|
|
11
|
-
isUpdateImportsCodeAction,
|
|
12
|
-
runFilteredCodeActionRefactor,
|
|
10
|
+
runCodeActionRefactor,
|
|
13
11
|
runRenameRefactor,
|
|
12
|
+
runSourceActionRefactor,
|
|
13
|
+
wholeDocumentRange,
|
|
14
14
|
} from "./refactor-planning.ts";
|
|
15
15
|
|
|
16
16
|
/** Build optional refactor methods for the semantic provider adapter. */
|
|
@@ -45,12 +45,6 @@ async function planRefactor(
|
|
|
45
45
|
): Promise<RefactorResult> {
|
|
46
46
|
switch (request.operation) {
|
|
47
47
|
case "rename_symbol":
|
|
48
|
-
if (!request.newName) {
|
|
49
|
-
return {
|
|
50
|
-
kind: "unavailable",
|
|
51
|
-
reason: 'Refactor operation "rename_symbol" requires `newName`.',
|
|
52
|
-
};
|
|
53
|
-
}
|
|
54
48
|
return runRenameRefactor({
|
|
55
49
|
lsp,
|
|
56
50
|
file: request.file,
|
|
@@ -58,39 +52,31 @@ async function planRefactor(
|
|
|
58
52
|
newName: request.newName,
|
|
59
53
|
control,
|
|
60
54
|
});
|
|
61
|
-
case "
|
|
62
|
-
|
|
63
|
-
return {
|
|
64
|
-
kind: "unavailable",
|
|
65
|
-
reason: `Refactor operation "${request.operation}" is unavailable: standard LSP code actions do not provide a safe exact extraction-name contract.`,
|
|
66
|
-
};
|
|
67
|
-
case "update_imports":
|
|
68
|
-
return runFilteredCodeActionRefactor({
|
|
55
|
+
case "code_action":
|
|
56
|
+
return runCodeActionRefactor({
|
|
69
57
|
lsp,
|
|
70
58
|
file: request.file,
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
59
|
+
range: request.range,
|
|
60
|
+
kind: request.kind,
|
|
61
|
+
title: request.title,
|
|
62
|
+
label: "Code action",
|
|
74
63
|
control,
|
|
75
64
|
});
|
|
76
|
-
case "
|
|
77
|
-
|
|
65
|
+
case "source_action": {
|
|
66
|
+
// LSP source actions apply to the entire file, so request the whole document.
|
|
67
|
+
const range = wholeDocumentRange(request.file);
|
|
68
|
+
if (!range) {
|
|
69
|
+
return { kind: "unavailable", reason: `File ${request.file} could not be read.` };
|
|
70
|
+
}
|
|
71
|
+
return runSourceActionRefactor({
|
|
78
72
|
lsp,
|
|
79
73
|
file: request.file,
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
74
|
+
range,
|
|
75
|
+
kind: request.kind,
|
|
76
|
+
title: request.title,
|
|
77
|
+
label: "Source action",
|
|
83
78
|
control,
|
|
84
79
|
});
|
|
85
|
-
|
|
86
|
-
case "move_file":
|
|
87
|
-
return {
|
|
88
|
-
kind: "unavailable",
|
|
89
|
-
reason: `Refactor operation "${request.operation}" is not supported yet. File/resource operations are deferred.`,
|
|
90
|
-
};
|
|
80
|
+
}
|
|
91
81
|
}
|
|
92
|
-
return {
|
|
93
|
-
kind: "unavailable",
|
|
94
|
-
reason: `Refactor operation "${request.operation}" is not supported by the active semantic provider.`,
|
|
95
|
-
};
|
|
96
82
|
}
|
|
@@ -0,0 +1,139 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Plan command-only code actions by capturing the edit their command pushes.
|
|
3
|
+
*
|
|
4
|
+
* Only `refactor*`, `source.organizeImports*`, and `source.fixAll*` commands
|
|
5
|
+
* may run, and only when the server lists the command (if it lists any). Other
|
|
6
|
+
* source commands can have side effects outside the editor, so they never run.
|
|
7
|
+
* Several eligible actions stay ambiguous without running any command.
|
|
8
|
+
*/
|
|
9
|
+
|
|
10
|
+
import type {
|
|
11
|
+
CodeRequestControl,
|
|
12
|
+
DisambiguationCandidate,
|
|
13
|
+
DocumentEditPrecondition,
|
|
14
|
+
RefactorResult,
|
|
15
|
+
} from "@mrclrchtr/supi-code-runtime/api";
|
|
16
|
+
import { isCodeActionKindWithin } from "../config/operation-support.ts";
|
|
17
|
+
import type { CodeAction, Command } from "../config/types.ts";
|
|
18
|
+
import type { WorkspaceLspRuntime } from "../session/workspace-lsp-runtime.ts";
|
|
19
|
+
import { normalizeSemanticEdit } from "./semantic-edit-normalizer.ts";
|
|
20
|
+
|
|
21
|
+
const CAPTURE_ELIGIBLE_KINDS = ["refactor", "source.organizeImports", "source.fixAll"] as const;
|
|
22
|
+
|
|
23
|
+
/**
|
|
24
|
+
* Stable reason for command-only actions SuPi will not run: an ineligible kind
|
|
25
|
+
* or a command the server does not list.
|
|
26
|
+
*/
|
|
27
|
+
export const COMMAND_ONLY_ACTION_REASON =
|
|
28
|
+
"Matching code actions only run a server command that SuPi does not run for preview.";
|
|
29
|
+
|
|
30
|
+
/** A code action whose only effect is a server command. */
|
|
31
|
+
export type CommandOnlyAction = CodeAction & { command: Command; kind: string };
|
|
32
|
+
|
|
33
|
+
/** Whether a code action has a command and no edit. */
|
|
34
|
+
export function isCommandOnlyAction(action: CodeAction): boolean {
|
|
35
|
+
return Object.hasOwn(action, "command") && !action.edit;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
/**
|
|
39
|
+
* Select the command-only actions SuPi may run to capture an edit: an eligible
|
|
40
|
+
* kind, and a command the server lists when it lists any.
|
|
41
|
+
*/
|
|
42
|
+
export function captureEligibleActions(
|
|
43
|
+
actions: readonly CodeAction[],
|
|
44
|
+
advertisedCommands: readonly string[] | undefined,
|
|
45
|
+
): CommandOnlyAction[] {
|
|
46
|
+
return actions.filter((action): action is CommandOnlyAction => {
|
|
47
|
+
const command = action.command;
|
|
48
|
+
return (
|
|
49
|
+
isCommandOnlyAction(action) &&
|
|
50
|
+
typeof action.kind === "string" &&
|
|
51
|
+
typeof command?.command === "string" &&
|
|
52
|
+
CAPTURE_ELIGIBLE_KINDS.some((kind) => isCodeActionKindWithin(action.kind, kind)) &&
|
|
53
|
+
(advertisedCommands === undefined || advertisedCommands.includes(command.command))
|
|
54
|
+
);
|
|
55
|
+
});
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
/** Candidates for several eligible command-only actions; no command has run. */
|
|
59
|
+
export function commandCandidates(actions: readonly CommandOnlyAction[]): RefactorResult {
|
|
60
|
+
return {
|
|
61
|
+
kind: "ambiguous",
|
|
62
|
+
candidates: actions.map(
|
|
63
|
+
(action): DisambiguationCandidate => ({
|
|
64
|
+
description: action.title,
|
|
65
|
+
kind: action.kind,
|
|
66
|
+
title: action.title,
|
|
67
|
+
}),
|
|
68
|
+
),
|
|
69
|
+
};
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
/**
|
|
73
|
+
* Run one action's command, capture its single pushed edit, and normalize it
|
|
74
|
+
* like a direct edit. Versioned preconditions move to the resynced versions,
|
|
75
|
+
* which hold the same content.
|
|
76
|
+
*/
|
|
77
|
+
export async function captureCommandAction(options: {
|
|
78
|
+
lsp: WorkspaceLspRuntime;
|
|
79
|
+
file: string;
|
|
80
|
+
action: CommandOnlyAction;
|
|
81
|
+
control?: CodeRequestControl;
|
|
82
|
+
}): Promise<RefactorResult> {
|
|
83
|
+
const { lsp, file, action, control } = options;
|
|
84
|
+
const response = await lsp.captureCodeActionEdit(file, action, control);
|
|
85
|
+
if (!response) {
|
|
86
|
+
return { kind: "unavailable", reason: "No routed LSP client could run the command." };
|
|
87
|
+
}
|
|
88
|
+
const roots = [...response.authorizedMutationRoots];
|
|
89
|
+
const capture = response.value;
|
|
90
|
+
if (!capture || capture.kind === "unavailable") {
|
|
91
|
+
return {
|
|
92
|
+
kind: "unavailable",
|
|
93
|
+
reason: `Command for "${action.title}" is unavailable: ${capture?.reason ?? response.reason ?? "no result."}`,
|
|
94
|
+
authorizedMutationRoots: roots,
|
|
95
|
+
};
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
const before = new Map(capture.resynced.map((entry) => [entry.file, entry]));
|
|
99
|
+
const result = normalizeSemanticEdit(
|
|
100
|
+
{ kind: "workspace-edit", edit: capture.edit },
|
|
101
|
+
{
|
|
102
|
+
// Captured edits target the versions from before the resync.
|
|
103
|
+
getOpenDocumentVersion: (candidate) => {
|
|
104
|
+
const current = lsp.getOpenDocumentVersion(candidate);
|
|
105
|
+
const versions = before.get(candidate);
|
|
106
|
+
return versions && current === versions.to ? versions.from : current;
|
|
107
|
+
},
|
|
108
|
+
authorizedMutationRoots: response.authorizedMutationRoots,
|
|
109
|
+
},
|
|
110
|
+
);
|
|
111
|
+
if (result.kind !== "precise") {
|
|
112
|
+
return result.kind === "unavailable"
|
|
113
|
+
? {
|
|
114
|
+
kind: "unavailable",
|
|
115
|
+
reason: `Captured edit for "${action.title}" could not produce precise edits: ${result.reason}`,
|
|
116
|
+
authorizedMutationRoots: roots,
|
|
117
|
+
}
|
|
118
|
+
: result;
|
|
119
|
+
}
|
|
120
|
+
const preconditions = result.edits.documentPreconditions?.map((precondition) =>
|
|
121
|
+
rebase(precondition, before),
|
|
122
|
+
);
|
|
123
|
+
return {
|
|
124
|
+
...result,
|
|
125
|
+
edits: { ...result.edits, ...(preconditions ? { documentPreconditions: preconditions } : {}) },
|
|
126
|
+
action: { kind: action.kind, title: action.title, provenance: "captured-command" },
|
|
127
|
+
};
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
function rebase(
|
|
131
|
+
precondition: DocumentEditPrecondition,
|
|
132
|
+
resynced: ReadonlyMap<string, { from: number; to: number }>,
|
|
133
|
+
): DocumentEditPrecondition {
|
|
134
|
+
if (precondition.kind === "disk-content") return precondition;
|
|
135
|
+
const versions = resynced.get(precondition.file);
|
|
136
|
+
return versions && precondition.version === versions.from
|
|
137
|
+
? { ...precondition, version: versions.to }
|
|
138
|
+
: precondition;
|
|
139
|
+
}
|
|
@@ -1,14 +1,28 @@
|
|
|
1
|
+
import { readFileSync } from "node:fs";
|
|
1
2
|
import * as path from "node:path";
|
|
2
3
|
import type {
|
|
3
4
|
CodePosition,
|
|
4
5
|
CodeRequestControl,
|
|
6
|
+
DisambiguationCandidate,
|
|
7
|
+
RefactorActionIdentity,
|
|
5
8
|
RefactorResult,
|
|
6
9
|
SourceRange,
|
|
7
10
|
} from "@mrclrchtr/supi-code-runtime/api";
|
|
8
11
|
import { CodeActionTriggerKind } from "vscode-languageserver-types";
|
|
9
|
-
import {
|
|
12
|
+
import { isCodeActionKindInRange, isCodeActionKindWithin } from "../config/operation-support.ts";
|
|
10
13
|
import type { CodeAction } from "../config/types.ts";
|
|
11
|
-
import
|
|
14
|
+
import { raceRequestControl } from "../session/readiness.ts";
|
|
15
|
+
import type { RoutedCodeActionResponse, WorkspaceLspRuntime } from "../session/runtime-registry.ts";
|
|
16
|
+
import {
|
|
17
|
+
COMMAND_ONLY_ACTION_REASON,
|
|
18
|
+
captureCommandAction,
|
|
19
|
+
captureEligibleActions,
|
|
20
|
+
commandCandidates,
|
|
21
|
+
isCommandOnlyAction,
|
|
22
|
+
} from "./refactor-command-capture.ts";
|
|
23
|
+
|
|
24
|
+
export { COMMAND_ONLY_ACTION_REASON };
|
|
25
|
+
|
|
12
26
|
import {
|
|
13
27
|
normalizeSemanticEdit,
|
|
14
28
|
type SemanticEditNormalizationContext,
|
|
@@ -70,48 +84,135 @@ export function collectCodeActionResults(
|
|
|
70
84
|
return results;
|
|
71
85
|
}
|
|
72
86
|
|
|
73
|
-
|
|
87
|
+
/** Options for one code- or source-action planning request. */
|
|
88
|
+
export interface CodeActionRefactorOptions {
|
|
74
89
|
lsp: WorkspaceLspRuntime;
|
|
75
90
|
file: string;
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
91
|
+
range: SourceRange;
|
|
92
|
+
kind: string;
|
|
93
|
+
title?: string;
|
|
94
|
+
/** Operation label used in unavailable reasons. */
|
|
95
|
+
label: "Code action" | "Source action";
|
|
80
96
|
control?: CodeRequestControl;
|
|
81
|
-
}
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
/**
|
|
100
|
+
* Plan one code action of the requested kind over a file range.
|
|
101
|
+
*
|
|
102
|
+
* `kind` matches itself and its dotted sub-kinds, per the LSP CodeActionKind
|
|
103
|
+
* hierarchy. Disabled actions never match. `title` narrows matches to one exact
|
|
104
|
+
* title. Distinct precise plans stay ambiguous. One eligible command-only
|
|
105
|
+
* action runs once so its pushed edit can be captured; see
|
|
106
|
+
* `refactor-command-capture.ts`.
|
|
107
|
+
*/
|
|
108
|
+
export async function runCodeActionRefactor(
|
|
109
|
+
options: CodeActionRefactorOptions,
|
|
110
|
+
): Promise<RefactorResult> {
|
|
111
|
+
return (await attemptCodeActionRefactor(options)).result;
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
/** Delays before re-requesting a source action that returned no action of the kind. */
|
|
115
|
+
const SOURCE_ACTION_RETRY_DELAYS_MS = [500, 1000] as const;
|
|
116
|
+
|
|
117
|
+
/**
|
|
118
|
+
* Plan a whole-file source action, retrying briefly when a server that
|
|
119
|
+
* advertises the requested kind returns no action of it.
|
|
120
|
+
*
|
|
121
|
+
* typescript-language-server returns no fix-all or unused-code source actions
|
|
122
|
+
* while diagnostics for a just-opened or just-changed file are pending, and
|
|
123
|
+
* waits itself about 500 ms in the equivalent quick-fix path.
|
|
124
|
+
*/
|
|
125
|
+
export async function runSourceActionRefactor(
|
|
126
|
+
options: CodeActionRefactorOptions,
|
|
127
|
+
): Promise<RefactorResult> {
|
|
128
|
+
let attempt = await attemptCodeActionRefactor(options);
|
|
129
|
+
for (const delayMs of SOURCE_ACTION_RETRY_DELAYS_MS) {
|
|
130
|
+
if (!attempt.retryable) break;
|
|
131
|
+
await raceRequestControl(
|
|
132
|
+
new Promise((resolve) => setTimeout(resolve, delayMs)),
|
|
133
|
+
options.control,
|
|
134
|
+
);
|
|
135
|
+
attempt = await attemptCodeActionRefactor(options);
|
|
136
|
+
}
|
|
137
|
+
return attempt.result;
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
/**
|
|
141
|
+
* One planning attempt. `retryable` marks a zero-match response from a server
|
|
142
|
+
* that advertises the requested kind, so a later request may still return it.
|
|
143
|
+
*/
|
|
144
|
+
async function attemptCodeActionRefactor(
|
|
145
|
+
options: CodeActionRefactorOptions,
|
|
146
|
+
): Promise<{ result: RefactorResult; retryable: boolean }> {
|
|
147
|
+
const { lsp, file, range, kind, title, label } = options;
|
|
148
|
+
const response = await lsp.codeActions(file, range, options.control, {
|
|
149
|
+
only: [kind],
|
|
85
150
|
triggerKind: CodeActionTriggerKind.Invoked,
|
|
86
151
|
});
|
|
87
|
-
if (!response
|
|
152
|
+
if (!response) {
|
|
88
153
|
return {
|
|
89
|
-
|
|
90
|
-
|
|
154
|
+
result: {
|
|
155
|
+
kind: "unavailable",
|
|
156
|
+
reason: `${label} "${kind}" is unavailable: no routed LSP client.`,
|
|
157
|
+
},
|
|
158
|
+
retryable: false,
|
|
91
159
|
};
|
|
92
160
|
}
|
|
93
|
-
const
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
161
|
+
const roots = [...response.authorizedMutationRoots];
|
|
162
|
+
const unavailable = (reason: string, retryable = false) => ({
|
|
163
|
+
result: { kind: "unavailable" as const, reason, authorizedMutationRoots: roots },
|
|
164
|
+
retryable,
|
|
165
|
+
});
|
|
166
|
+
if (response.reason || !response.value) {
|
|
167
|
+
return unavailable(
|
|
168
|
+
`${label} "${kind}" is unavailable: ${response.reason ?? "no code actions were returned."}`,
|
|
169
|
+
);
|
|
99
170
|
}
|
|
100
171
|
|
|
101
|
-
const
|
|
172
|
+
const ofKind = response.value
|
|
173
|
+
.filter(isTitledCodeAction)
|
|
174
|
+
.filter(
|
|
175
|
+
(action) => isCodeActionKindWithin(action.kind, kind) && !Object.hasOwn(action, "disabled"),
|
|
176
|
+
);
|
|
177
|
+
if (ofKind.length === 0) {
|
|
178
|
+
const advertised = advertisedFamilyKinds(response.advertisedKinds, kind);
|
|
179
|
+
return unavailable(
|
|
180
|
+
noKindMatchReason(kind, advertised),
|
|
181
|
+
advertised.kinds.some((candidate) => isCodeActionKindInRange(candidate, kind)),
|
|
182
|
+
);
|
|
183
|
+
}
|
|
184
|
+
const matching = title === undefined ? ofKind : ofKind.filter((action) => action.title === title);
|
|
102
185
|
if (matching.length === 0) {
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
186
|
+
const titles = [...new Set(ofKind.map((action) => `"${action.title}"`))].join(", ");
|
|
187
|
+
return unavailable(
|
|
188
|
+
`No "${kind}" code action has the title "${title}". Available titles: ${titles}.`,
|
|
189
|
+
);
|
|
107
190
|
}
|
|
108
191
|
|
|
109
|
-
|
|
192
|
+
return { result: await planMatchingActions(options, matching, response), retryable: false };
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
/** Turn the matching actions into one plan, candidates, or an unavailable reason. */
|
|
196
|
+
async function planMatchingActions(
|
|
197
|
+
options: CodeActionRefactorOptions,
|
|
198
|
+
matching: CodeAction[],
|
|
199
|
+
response: RoutedCodeActionResponse,
|
|
200
|
+
): Promise<RefactorResult> {
|
|
201
|
+
const { lsp, file, kind } = options;
|
|
202
|
+
const roots = [...response.authorizedMutationRoots];
|
|
203
|
+
const unavailable = (reason: string): RefactorResult => ({
|
|
204
|
+
kind: "unavailable",
|
|
205
|
+
reason,
|
|
206
|
+
authorizedMutationRoots: roots,
|
|
207
|
+
});
|
|
208
|
+
const plans = collectPrecisePlans(matching, {
|
|
110
209
|
getOpenDocumentVersion: (candidate) => lsp.getOpenDocumentVersion(candidate),
|
|
111
210
|
authorizedMutationRoots: response.authorizedMutationRoots,
|
|
112
|
-
};
|
|
113
|
-
const
|
|
114
|
-
if (plans.precise.length === 1)
|
|
211
|
+
});
|
|
212
|
+
const [single] = plans.precise;
|
|
213
|
+
if (plans.precise.length === 1 && single) {
|
|
214
|
+
return { ...single.result, action: { ...actionIdentity(single.action), provenance: "edit" } };
|
|
215
|
+
}
|
|
115
216
|
if (plans.precise.length > 1) {
|
|
116
217
|
return {
|
|
117
218
|
kind: "ambiguous",
|
|
@@ -120,26 +221,84 @@ export async function runFilteredCodeActionRefactor(options: {
|
|
|
120
221
|
),
|
|
121
222
|
};
|
|
122
223
|
}
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
224
|
+
if (matching.every(isCommandOnlyAction)) {
|
|
225
|
+
const eligible = captureEligibleActions(matching, response.advertisedCommands);
|
|
226
|
+
const [only] = eligible;
|
|
227
|
+
if (eligible.length === 1 && only) {
|
|
228
|
+
return captureCommandAction({ lsp, file, action: only, control: options.control });
|
|
229
|
+
}
|
|
230
|
+
return eligible.length > 1
|
|
231
|
+
? commandCandidates(eligible)
|
|
232
|
+
: unavailable(COMMAND_ONLY_ACTION_REASON);
|
|
233
|
+
}
|
|
234
|
+
return unavailable(
|
|
235
|
+
plans.unavailableReason
|
|
126
236
|
? `Matching code action is unavailable: ${plans.unavailableReason}`
|
|
127
|
-
: `Matching
|
|
128
|
-
|
|
237
|
+
: `Matching "${kind}" code actions did not produce precise edits.`,
|
|
238
|
+
);
|
|
129
239
|
}
|
|
130
240
|
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
241
|
+
/** Compute the zero-based UTF-16 range that covers a file's full current disk text. */
|
|
242
|
+
export function wholeDocumentRange(file: string): SourceRange | null {
|
|
243
|
+
let text: string;
|
|
244
|
+
try {
|
|
245
|
+
text = readFileSync(file, "utf-8");
|
|
246
|
+
} catch {
|
|
247
|
+
return null;
|
|
248
|
+
}
|
|
249
|
+
const lines = text.split(/\r\n|\r|\n/);
|
|
250
|
+
return {
|
|
251
|
+
start: { line: 0, character: 0 },
|
|
252
|
+
end: { line: lines.length - 1, character: lines.at(-1)?.length ?? 0 },
|
|
253
|
+
};
|
|
134
254
|
}
|
|
135
255
|
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
256
|
+
function isTitledCodeAction(value: unknown): value is CodeAction {
|
|
257
|
+
return (
|
|
258
|
+
typeof value === "object" &&
|
|
259
|
+
value !== null &&
|
|
260
|
+
typeof (value as { title?: unknown }).title === "string"
|
|
140
261
|
);
|
|
141
262
|
}
|
|
142
263
|
|
|
264
|
+
/** Advertised kinds in one CodeActionKind family, such as `source*`. */
|
|
265
|
+
interface AdvertisedFamilyKinds {
|
|
266
|
+
/** Listed non-empty kinds in the requested kind's top-level family. */
|
|
267
|
+
readonly kinds: readonly string[];
|
|
268
|
+
/** The server lists CodeActionKind.Empty or no kinds, so it may return any kind. */
|
|
269
|
+
readonly anyKind: boolean;
|
|
270
|
+
}
|
|
271
|
+
|
|
272
|
+
function advertisedFamilyKinds(
|
|
273
|
+
advertised: readonly string[] | undefined,
|
|
274
|
+
kind: string,
|
|
275
|
+
): AdvertisedFamilyKinds {
|
|
276
|
+
const family = kind.split(".")[0] ?? kind;
|
|
277
|
+
return {
|
|
278
|
+
kinds: (advertised ?? []).filter(
|
|
279
|
+
(candidate) => candidate !== "" && isCodeActionKindWithin(candidate, family),
|
|
280
|
+
),
|
|
281
|
+
anyKind: !advertised || advertised.includes(""),
|
|
282
|
+
};
|
|
283
|
+
}
|
|
284
|
+
|
|
285
|
+
function noKindMatchReason(kind: string, advertised: AdvertisedFamilyKinds): string {
|
|
286
|
+
const parts = [`No code action matches kind "${kind}" here.`];
|
|
287
|
+
if (advertised.kinds.length > 0) {
|
|
288
|
+
parts.push(`Server-advertised kinds: ${advertised.kinds.join(", ")}.`);
|
|
289
|
+
}
|
|
290
|
+
if (advertised.anyKind) {
|
|
291
|
+
parts.push("The server may return any code-action kind but returned none of this kind.");
|
|
292
|
+
} else if (advertised.kinds.length === 0) {
|
|
293
|
+
parts.push("The server advertises no kinds in this family.");
|
|
294
|
+
}
|
|
295
|
+
return parts.join(" ");
|
|
296
|
+
}
|
|
297
|
+
|
|
298
|
+
function actionIdentity(action: CodeAction): RefactorActionIdentity {
|
|
299
|
+
return { kind: typeof action.kind === "string" ? action.kind : "", title: action.title };
|
|
300
|
+
}
|
|
301
|
+
|
|
143
302
|
interface PreciseCodeActionPlan {
|
|
144
303
|
action: CodeAction;
|
|
145
304
|
result: Extract<RefactorResult, { kind: "precise" }>;
|
|
@@ -187,18 +346,14 @@ function refactorCandidate(
|
|
|
187
346
|
result: Extract<RefactorResult, { kind: "precise" }>,
|
|
188
347
|
index: number,
|
|
189
348
|
plans: readonly { action: CodeAction }[],
|
|
190
|
-
): {
|
|
191
|
-
description: string;
|
|
192
|
-
file?: string;
|
|
193
|
-
line?: number;
|
|
194
|
-
character?: number;
|
|
195
|
-
} {
|
|
349
|
+
): DisambiguationCandidate {
|
|
196
350
|
const firstEdit = result.edits.edits[0];
|
|
197
351
|
const sameTitleCount = plans.filter((plan) => plan.action.title === action.title).length;
|
|
198
352
|
const description =
|
|
199
353
|
sameTitleCount > 1 ? `${action.title} (alternative ${index + 1})` : action.title;
|
|
200
354
|
return {
|
|
201
355
|
description,
|
|
356
|
+
...actionIdentity(action),
|
|
202
357
|
...(firstEdit
|
|
203
358
|
? {
|
|
204
359
|
file: firstEdit.file,
|
|
@@ -0,0 +1,26 @@
|
|
|
1
|
+
/** Project-root boundary for mutation requests on one routed client. */
|
|
2
|
+
|
|
3
|
+
import { realpathSync } from "node:fs";
|
|
4
|
+
import { isWithinOrEqual } from "@mrclrchtr/supi-core/project";
|
|
5
|
+
|
|
6
|
+
/**
|
|
7
|
+
* Return why a file cannot be refactored by the client routed to it, or null.
|
|
8
|
+
*
|
|
9
|
+
* A file without its own project markers routes to a server rooted at the
|
|
10
|
+
* session directory. Its edits would fail the apply-time root check, so refuse
|
|
11
|
+
* before the request. Real paths are compared, so a link inside the root
|
|
12
|
+
* cannot reach an outside file.
|
|
13
|
+
*/
|
|
14
|
+
export function outsideRouteRootReason(file: string, root: string): string | null {
|
|
15
|
+
return isWithinOrEqual(canonical(root), canonical(file))
|
|
16
|
+
? null
|
|
17
|
+
: `File ${file} is outside the language server's project root ${root}.`;
|
|
18
|
+
}
|
|
19
|
+
|
|
20
|
+
function canonical(file: string): string {
|
|
21
|
+
try {
|
|
22
|
+
return realpathSync(file);
|
|
23
|
+
} catch {
|
|
24
|
+
return file;
|
|
25
|
+
}
|
|
26
|
+
}
|