@howaboua/pi-better-skills-tool 0.0.1
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 +9 -0
- package/LICENSE +21 -0
- package/README.md +52 -0
- package/biome.json +31 -0
- package/changelog.ts +337 -0
- package/index.ts +101 -0
- package/package.json +76 -0
- package/src/catalog.ts +125 -0
- package/src/discovery.ts +246 -0
- package/src/skill-document.ts +133 -0
- package/src/skill-package.ts +253 -0
- package/src/tool.ts +56 -0
- package/tsconfig.json +7 -0
package/CHANGELOG.md
ADDED
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
# @howaboua/pi-better-skills-tool
|
|
2
|
+
|
|
3
|
+
## 0.0.1
|
|
4
|
+
|
|
5
|
+
- Initial release of Better Skills for progressive skill discovery in normal Pi, Code Mode, and Notebook Mode.
|
|
6
|
+
|
|
7
|
+
- List the available catalog first, then load only the requested skill and references.
|
|
8
|
+
- Combine global, project, and package-provided skills while respecting invocation visibility and local precedence.
|
|
9
|
+
|
package/LICENSE
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
MIT License
|
|
2
|
+
|
|
3
|
+
Copyright (c) 2026 Igor Warzocha
|
|
4
|
+
|
|
5
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
6
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
7
|
+
in the Software without restriction, including without limitation the rights
|
|
8
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
9
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
10
|
+
furnished to do so, subject to the following conditions:
|
|
11
|
+
|
|
12
|
+
The above copyright notice and this permission notice shall be included in all
|
|
13
|
+
copies or substantial portions of the Software.
|
|
14
|
+
|
|
15
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
16
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
17
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
18
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
19
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
20
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
21
|
+
SOFTWARE.
|
package/README.md
ADDED
|
@@ -0,0 +1,52 @@
|
|
|
1
|
+
# @howaboua/pi-better-skills-tool
|
|
2
|
+
|
|
3
|
+
Progressive skill discovery for Pi, Code Mode and Notebook Mode. The `skills` tool lists the active catalog by category, reads one skill, or reads selected references without loading an entire package into context.
|
|
4
|
+
|
|
5
|
+
## Install
|
|
6
|
+
|
|
7
|
+
```bash
|
|
8
|
+
pi install npm:@howaboua/pi-better-skills-tool
|
|
9
|
+
```
|
|
10
|
+
|
|
11
|
+
Install `@howaboua/pi-codex-conversion` 3.0.24 or newer too for Code Mode and Notebook Mode. The extension remains a normal Pi tool when Codex conversion is absent.
|
|
12
|
+
|
|
13
|
+
## Start Pi without native skills
|
|
14
|
+
|
|
15
|
+
This setup assumes agent sessions start with `--no-skills`. Pi then omits its native skill catalog from the initial prompt, while the `skills` tool owns progressive discovery. Without the flag, the extension still works but treats Pi's already-loaded catalog as authoritative.
|
|
16
|
+
|
|
17
|
+
Our wrapper adds `--no-skills` to agent sessions and passes every supplied Pi argument through unchanged. Package-management and configuration commands bypass the flag:
|
|
18
|
+
|
|
19
|
+
```zsh
|
|
20
|
+
#!/usr/bin/env zsh
|
|
21
|
+
set -euo pipefail
|
|
22
|
+
|
|
23
|
+
real_pi="$HOME/.cache/.bun/bin/pi"
|
|
24
|
+
|
|
25
|
+
case "${1-}" in
|
|
26
|
+
install|remove|uninstall|update|list|config|auth)
|
|
27
|
+
exec "$real_pi" "$@"
|
|
28
|
+
;;
|
|
29
|
+
*)
|
|
30
|
+
exec "$real_pi" --no-skills "$@"
|
|
31
|
+
;;
|
|
32
|
+
esac
|
|
33
|
+
```
|
|
34
|
+
|
|
35
|
+
Put the wrapper earlier on `PATH` than the real Pi executable. Change `real_pi` when Pi was installed somewhere other than Bun's global binary directory. Quoted `"$@"` preserves each argument exactly, including spaces and repeated flags.
|
|
36
|
+
|
|
37
|
+
## Use
|
|
38
|
+
|
|
39
|
+
Normal Pi uses one structured `command` parameter. Code Mode and Notebook Mode use the compact string surface:
|
|
40
|
+
|
|
41
|
+
```js
|
|
42
|
+
await tools.skills("list")
|
|
43
|
+
await tools.skills("list code session")
|
|
44
|
+
await tools.skills("read code-review")
|
|
45
|
+
await tools.skills("read codebase-hygiene testing js-ts")
|
|
46
|
+
```
|
|
47
|
+
|
|
48
|
+
Pi's loaded skill catalog is authoritative during normal use. When Pi has no loaded skills, including `--no-skills` sessions, the tool falls back to the standard global `skills/` directory under Pi's agent directory and `$PWD/.pi/skills/`. A same-named session skill overrides the global skill. Reads return the requested Markdown and absolute package paths for later reference, script, or asset access.
|
|
49
|
+
|
|
50
|
+
Remove or disable any legacy `codex-conversion-custom-tools/skills.toml` after installing this extension. Keeping both definitions gives Code Mode two tools named `skills`, which it rejects.
|
|
51
|
+
|
|
52
|
+
The Code Mode surface is freeform because its input is already a compact routed command. It does not add a provider grammar. Code Mode's outer `exec` grammar remains the only constrained grammar involved.
|
package/biome.json
ADDED
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
{
|
|
2
|
+
"$schema": "https://biomejs.dev/schemas/2.5.10/schema.json",
|
|
3
|
+
"vcs": {
|
|
4
|
+
"enabled": true,
|
|
5
|
+
"clientKind": "git",
|
|
6
|
+
"useIgnoreFile": false
|
|
7
|
+
},
|
|
8
|
+
"files": {
|
|
9
|
+
"includes": [
|
|
10
|
+
"**",
|
|
11
|
+
"!node_modules",
|
|
12
|
+
"!dist",
|
|
13
|
+
"!coverage",
|
|
14
|
+
"!package-lock.json"
|
|
15
|
+
]
|
|
16
|
+
},
|
|
17
|
+
"formatter": {
|
|
18
|
+
"enabled": true,
|
|
19
|
+
"indentStyle": "tab"
|
|
20
|
+
},
|
|
21
|
+
"linter": {
|
|
22
|
+
"enabled": false
|
|
23
|
+
},
|
|
24
|
+
"javascript": {
|
|
25
|
+
"formatter": {
|
|
26
|
+
"quoteStyle": "double",
|
|
27
|
+
"semicolons": "always",
|
|
28
|
+
"trailingCommas": "all"
|
|
29
|
+
}
|
|
30
|
+
}
|
|
31
|
+
}
|
package/changelog.ts
ADDED
|
@@ -0,0 +1,337 @@
|
|
|
1
|
+
// Generated extension packages copy this file during changelog:extensions.
|
|
2
|
+
|
|
3
|
+
import { randomUUID } from "node:crypto";
|
|
4
|
+
import { readFileSync } from "node:fs";
|
|
5
|
+
import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
|
|
6
|
+
import { dirname, join } from "node:path";
|
|
7
|
+
import { fileURLToPath } from "node:url";
|
|
8
|
+
import {
|
|
9
|
+
DynamicBorder,
|
|
10
|
+
type ExtensionAPI,
|
|
11
|
+
getAgentDir,
|
|
12
|
+
getMarkdownTheme,
|
|
13
|
+
} from "@earendil-works/pi-coding-agent";
|
|
14
|
+
import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
|
|
15
|
+
|
|
16
|
+
const ENTRY_TYPE = "@howaboua/pi-stuff/changelog";
|
|
17
|
+
const REGISTRATION_CHANNEL = "@howaboua/pi-stuff/changelog/register/v1";
|
|
18
|
+
const STATE_FILENAME = "howaboua-pi-stuff-changelog.json";
|
|
19
|
+
const SUPPRESS_KEY = "suppress";
|
|
20
|
+
const LOCK_STALE_MS = 30_000;
|
|
21
|
+
const LOCK_TIMEOUT_MS = 2_000;
|
|
22
|
+
|
|
23
|
+
interface PackageMetadata {
|
|
24
|
+
name: string;
|
|
25
|
+
version: string;
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
interface PackageRegistration extends PackageMetadata {
|
|
29
|
+
changelogPath: string;
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
interface RegistrationEvent {
|
|
33
|
+
accept: () => void;
|
|
34
|
+
registration: PackageRegistration;
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
interface ChangelogEntry {
|
|
38
|
+
content: string;
|
|
39
|
+
version: string;
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
interface ChangelogEntryData {
|
|
43
|
+
markdown: string;
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
type ChangelogState = Record<string, boolean | string>;
|
|
47
|
+
|
|
48
|
+
function packageRegistration(): PackageRegistration {
|
|
49
|
+
const packageDirectory = fileURLToPath(new URL(".", import.meta.url));
|
|
50
|
+
const metadata = JSON.parse(
|
|
51
|
+
readFileSync(join(packageDirectory, "package.json"), "utf8"),
|
|
52
|
+
) as Partial<PackageMetadata>;
|
|
53
|
+
if (typeof metadata.name !== "string" || typeof metadata.version !== "string")
|
|
54
|
+
throw new Error(`Invalid package metadata in ${packageDirectory}`);
|
|
55
|
+
return {
|
|
56
|
+
name: metadata.name,
|
|
57
|
+
version: metadata.version,
|
|
58
|
+
changelogPath: join(packageDirectory, "CHANGELOG.md"),
|
|
59
|
+
};
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
function isRegistrationEvent(value: unknown): value is RegistrationEvent {
|
|
63
|
+
if (!value || typeof value !== "object") return false;
|
|
64
|
+
const event = value as Partial<RegistrationEvent>;
|
|
65
|
+
return (
|
|
66
|
+
typeof event.accept === "function" &&
|
|
67
|
+
typeof event.registration?.name === "string" &&
|
|
68
|
+
typeof event.registration.version === "string" &&
|
|
69
|
+
typeof event.registration.changelogPath === "string"
|
|
70
|
+
);
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
function parseChangelog(markdown: string): ChangelogEntry[] {
|
|
74
|
+
const entries: ChangelogEntry[] = [];
|
|
75
|
+
let currentLines: string[] = [];
|
|
76
|
+
let currentVersion: string | undefined;
|
|
77
|
+
|
|
78
|
+
for (const line of markdown.split("\n")) {
|
|
79
|
+
const version = line.match(/^##\s+\[?(\d+\.\d+\.\d+)\]?(?:\s.*)?$/)?.[1];
|
|
80
|
+
if (version) {
|
|
81
|
+
if (currentVersion)
|
|
82
|
+
entries.push({
|
|
83
|
+
content: currentLines.join("\n").trim(),
|
|
84
|
+
version: currentVersion,
|
|
85
|
+
});
|
|
86
|
+
currentVersion = version;
|
|
87
|
+
currentLines = [line];
|
|
88
|
+
} else if (currentVersion) {
|
|
89
|
+
currentLines.push(line);
|
|
90
|
+
}
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
if (currentVersion)
|
|
94
|
+
entries.push({
|
|
95
|
+
content: currentLines.join("\n").trim(),
|
|
96
|
+
version: currentVersion,
|
|
97
|
+
});
|
|
98
|
+
return entries;
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
function compareVersions(left: string, right: string): number {
|
|
102
|
+
const leftParts = left.split(".").map(Number);
|
|
103
|
+
const rightParts = right.split(".").map(Number);
|
|
104
|
+
for (let index = 0; index < 3; index++) {
|
|
105
|
+
const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
|
|
106
|
+
if (difference !== 0) return difference;
|
|
107
|
+
}
|
|
108
|
+
return 0;
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
function isStableVersion(version: string): boolean {
|
|
112
|
+
return /^\d+\.\d+\.\d+$/.test(version);
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
function statePath(): string {
|
|
116
|
+
return join(getAgentDir(), STATE_FILENAME);
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
async function readState(path: string): Promise<ChangelogState> {
|
|
120
|
+
let text: string;
|
|
121
|
+
try {
|
|
122
|
+
text = await readFile(path, "utf8");
|
|
123
|
+
} catch (error) {
|
|
124
|
+
if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
|
|
125
|
+
throw error;
|
|
126
|
+
}
|
|
127
|
+
const parsed = JSON.parse(text) as unknown;
|
|
128
|
+
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
|
|
129
|
+
throw new Error(`${path} must contain a JSON object`);
|
|
130
|
+
for (const [name, value] of Object.entries(parsed)) {
|
|
131
|
+
if (name === SUPPRESS_KEY) {
|
|
132
|
+
if (typeof value !== "boolean")
|
|
133
|
+
throw new Error(`${path} ${SUPPRESS_KEY} must be a boolean`);
|
|
134
|
+
} else if (typeof value !== "string") {
|
|
135
|
+
throw new Error(`${path} version for ${name} must be a string`);
|
|
136
|
+
}
|
|
137
|
+
}
|
|
138
|
+
return parsed as ChangelogState;
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
async function acquireLock(path: string): Promise<() => Promise<void>> {
|
|
142
|
+
const deadline = Date.now() + LOCK_TIMEOUT_MS;
|
|
143
|
+
while (true) {
|
|
144
|
+
try {
|
|
145
|
+
await mkdir(path);
|
|
146
|
+
return () => rm(path, { force: true, recursive: true });
|
|
147
|
+
} catch (error) {
|
|
148
|
+
if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
|
|
149
|
+
const info = await stat(path).catch(() => undefined);
|
|
150
|
+
if (info && Date.now() - info.mtimeMs > LOCK_STALE_MS) {
|
|
151
|
+
await rm(path, { force: true, recursive: true });
|
|
152
|
+
continue;
|
|
153
|
+
}
|
|
154
|
+
if (Date.now() >= deadline)
|
|
155
|
+
throw new Error(`Timed out waiting for ${path}`);
|
|
156
|
+
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
157
|
+
}
|
|
158
|
+
}
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
async function writeState(path: string, state: ChangelogState): Promise<void> {
|
|
162
|
+
await mkdir(dirname(path), { mode: 0o700, recursive: true });
|
|
163
|
+
const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
|
|
164
|
+
try {
|
|
165
|
+
const ordered = Object.fromEntries(
|
|
166
|
+
Object.entries(state).sort(([left], [right]) =>
|
|
167
|
+
left.localeCompare(right),
|
|
168
|
+
),
|
|
169
|
+
);
|
|
170
|
+
await writeFile(temporaryPath, `${JSON.stringify(ordered, null, 2)}\n`, {
|
|
171
|
+
encoding: "utf8",
|
|
172
|
+
mode: 0o600,
|
|
173
|
+
});
|
|
174
|
+
await rename(temporaryPath, path);
|
|
175
|
+
} catch (error) {
|
|
176
|
+
await rm(temporaryPath, { force: true });
|
|
177
|
+
throw error;
|
|
178
|
+
}
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
function packageMarkdown(
|
|
182
|
+
registration: PackageRegistration,
|
|
183
|
+
entries: ChangelogEntry[],
|
|
184
|
+
): string {
|
|
185
|
+
const body = (entry: ChangelogEntry) =>
|
|
186
|
+
entry.content
|
|
187
|
+
.replace(/^##[^\n]*\n*/, "")
|
|
188
|
+
.replace(/^###\s+(?:Changes|Minor Changes|Patch Changes)\s*\n*/gim, "")
|
|
189
|
+
.replace(/^###\s+(.+)$/gm, "**$1**");
|
|
190
|
+
if (entries.length === 1) {
|
|
191
|
+
const [entry] = entries;
|
|
192
|
+
if (!entry) return "";
|
|
193
|
+
return `## ${registration.name} ${entry.version}\n\n${body(entry)}`;
|
|
194
|
+
}
|
|
195
|
+
return [
|
|
196
|
+
`## ${registration.name}`,
|
|
197
|
+
...entries.map((entry) => `**${entry.version}**\n\n${body(entry)}`),
|
|
198
|
+
].join("\n\n");
|
|
199
|
+
}
|
|
200
|
+
|
|
201
|
+
async function claimUpdates(
|
|
202
|
+
registrations: Iterable<PackageRegistration>,
|
|
203
|
+
): Promise<{ errors: string[]; markdown?: string }> {
|
|
204
|
+
const stableRegistrations = [...registrations]
|
|
205
|
+
.filter((registration) => isStableVersion(registration.version))
|
|
206
|
+
.sort((left, right) => left.name.localeCompare(right.name));
|
|
207
|
+
if (stableRegistrations.length === 0) return { errors: [] };
|
|
208
|
+
const path = statePath();
|
|
209
|
+
await mkdir(dirname(path), { mode: 0o700, recursive: true });
|
|
210
|
+
const release = await acquireLock(`${path}.lock`);
|
|
211
|
+
try {
|
|
212
|
+
const state = await readState(path);
|
|
213
|
+
const errors: string[] = [];
|
|
214
|
+
const sections: string[] = [];
|
|
215
|
+
let changed = false;
|
|
216
|
+
if (state[SUPPRESS_KEY] === true) {
|
|
217
|
+
for (const registration of stableRegistrations) {
|
|
218
|
+
const seenVersion = state[registration.name];
|
|
219
|
+
if (
|
|
220
|
+
typeof seenVersion !== "string" ||
|
|
221
|
+
compareVersions(registration.version, seenVersion) > 0
|
|
222
|
+
) {
|
|
223
|
+
state[registration.name] = registration.version;
|
|
224
|
+
changed = true;
|
|
225
|
+
}
|
|
226
|
+
}
|
|
227
|
+
if (changed) await writeState(path, state);
|
|
228
|
+
return { errors };
|
|
229
|
+
}
|
|
230
|
+
for (const registration of stableRegistrations) {
|
|
231
|
+
const seenVersion = state[registration.name];
|
|
232
|
+
if (
|
|
233
|
+
typeof seenVersion === "string" &&
|
|
234
|
+
compareVersions(registration.version, seenVersion) <= 0
|
|
235
|
+
)
|
|
236
|
+
continue;
|
|
237
|
+
try {
|
|
238
|
+
const entries = parseChangelog(
|
|
239
|
+
await readFile(registration.changelogPath, "utf8"),
|
|
240
|
+
).filter(
|
|
241
|
+
(entry) =>
|
|
242
|
+
compareVersions(entry.version, registration.version) <= 0 &&
|
|
243
|
+
(typeof seenVersion === "string"
|
|
244
|
+
? compareVersions(entry.version, seenVersion) > 0
|
|
245
|
+
: entry.version === registration.version),
|
|
246
|
+
);
|
|
247
|
+
if (entries.length === 0) {
|
|
248
|
+
errors.push(
|
|
249
|
+
`No ${registration.version} changelog entry found for ${registration.name}`,
|
|
250
|
+
);
|
|
251
|
+
continue;
|
|
252
|
+
}
|
|
253
|
+
sections.push(packageMarkdown(registration, entries));
|
|
254
|
+
state[registration.name] = registration.version;
|
|
255
|
+
changed = true;
|
|
256
|
+
} catch (error) {
|
|
257
|
+
errors.push(
|
|
258
|
+
`Could not read the ${registration.name} changelog: ${error instanceof Error ? error.message : String(error)}`,
|
|
259
|
+
);
|
|
260
|
+
}
|
|
261
|
+
}
|
|
262
|
+
if (changed) await writeState(path, state);
|
|
263
|
+
return {
|
|
264
|
+
errors,
|
|
265
|
+
...(sections.length > 0 ? { markdown: sections.join("\n\n") } : {}),
|
|
266
|
+
};
|
|
267
|
+
} finally {
|
|
268
|
+
await release();
|
|
269
|
+
}
|
|
270
|
+
}
|
|
271
|
+
|
|
272
|
+
function registerCoordinator(
|
|
273
|
+
pi: ExtensionAPI,
|
|
274
|
+
registration: PackageRegistration,
|
|
275
|
+
): void {
|
|
276
|
+
let accepted = false;
|
|
277
|
+
pi.events.emit(REGISTRATION_CHANNEL, {
|
|
278
|
+
registration,
|
|
279
|
+
accept: () => {
|
|
280
|
+
accepted = true;
|
|
281
|
+
},
|
|
282
|
+
} satisfies RegistrationEvent);
|
|
283
|
+
if (accepted) return;
|
|
284
|
+
|
|
285
|
+
const registrations = new Map([[registration.name, registration]]);
|
|
286
|
+
pi.events.on(REGISTRATION_CHANNEL, (value) => {
|
|
287
|
+
if (!isRegistrationEvent(value)) return;
|
|
288
|
+
registrations.set(value.registration.name, value.registration);
|
|
289
|
+
value.accept();
|
|
290
|
+
});
|
|
291
|
+
pi.registerEntryRenderer<ChangelogEntryData>(
|
|
292
|
+
ENTRY_TYPE,
|
|
293
|
+
(entry, _options, theme) => {
|
|
294
|
+
if (!entry.data) return undefined;
|
|
295
|
+
const container = new Container();
|
|
296
|
+
container.addChild(new DynamicBorder());
|
|
297
|
+
container.addChild(
|
|
298
|
+
new Text(theme.bold(theme.fg("accent", "What's New")), 1, 0),
|
|
299
|
+
);
|
|
300
|
+
container.addChild(new Spacer(1));
|
|
301
|
+
container.addChild(
|
|
302
|
+
new Markdown(entry.data.markdown.trim(), 1, 0, getMarkdownTheme()),
|
|
303
|
+
);
|
|
304
|
+
container.addChild(new Spacer(1));
|
|
305
|
+
container.addChild(new DynamicBorder());
|
|
306
|
+
return container;
|
|
307
|
+
},
|
|
308
|
+
);
|
|
309
|
+
pi.on("session_start", async (event, ctx) => {
|
|
310
|
+
if (event.reason === "reload" || ctx.mode !== "tui") return;
|
|
311
|
+
if (
|
|
312
|
+
ctx.sessionManager
|
|
313
|
+
.getEntries()
|
|
314
|
+
.some((entry) =>
|
|
315
|
+
["branch_summary", "compaction", "message"].includes(entry.type),
|
|
316
|
+
)
|
|
317
|
+
)
|
|
318
|
+
return;
|
|
319
|
+
try {
|
|
320
|
+
const update = await claimUpdates(registrations.values());
|
|
321
|
+
if (update.markdown)
|
|
322
|
+
pi.appendEntry<ChangelogEntryData>(ENTRY_TYPE, {
|
|
323
|
+
markdown: update.markdown,
|
|
324
|
+
});
|
|
325
|
+
for (const error of update.errors) ctx.ui.notify(error, "warning");
|
|
326
|
+
} catch (error) {
|
|
327
|
+
ctx.ui.notify(
|
|
328
|
+
`Could not update Howaboua changelog state: ${error instanceof Error ? error.message : String(error)}`,
|
|
329
|
+
"warning",
|
|
330
|
+
);
|
|
331
|
+
}
|
|
332
|
+
});
|
|
333
|
+
}
|
|
334
|
+
|
|
335
|
+
export default function howabouaPackageChangelog(pi: ExtensionAPI): void {
|
|
336
|
+
registerCoordinator(pi, packageRegistration());
|
|
337
|
+
}
|
package/index.ts
ADDED
|
@@ -0,0 +1,101 @@
|
|
|
1
|
+
import type { ExtensionAPI, Skill } from "@earendil-works/pi-coding-agent";
|
|
2
|
+
import registerPackageChangelog from "./changelog.js";
|
|
3
|
+
import { createSkillsTool, prepareSkillsCodeModeInput } from "./src/tool.js";
|
|
4
|
+
|
|
5
|
+
export { createSkillsTool, prepareSkillsCodeModeInput } from "./src/tool.js";
|
|
6
|
+
|
|
7
|
+
const REGISTRATION_KEY = Symbol.for(
|
|
8
|
+
"@howaboua/pi-better-skills-tool.registered",
|
|
9
|
+
);
|
|
10
|
+
const CODE_MODE_PACKAGE = "@howaboua/pi-codex-conversion";
|
|
11
|
+
const CODE_MODE_MODULE = `${CODE_MODE_PACKAGE}/code-mode`;
|
|
12
|
+
|
|
13
|
+
export default async function skillsExtension(pi: ExtensionAPI): Promise<void> {
|
|
14
|
+
registerPackageChangelog(pi);
|
|
15
|
+
const sharedState = pi.events as typeof pi.events & {
|
|
16
|
+
[REGISTRATION_KEY]?: object;
|
|
17
|
+
};
|
|
18
|
+
if (sharedState[REGISTRATION_KEY]) return;
|
|
19
|
+
const owner = {};
|
|
20
|
+
sharedState[REGISTRATION_KEY] = owner;
|
|
21
|
+
|
|
22
|
+
let loadedSkills: readonly Skill[] = [];
|
|
23
|
+
pi.on("before_agent_start", (event) => {
|
|
24
|
+
loadedSkills = event.systemPromptOptions.skills ?? [];
|
|
25
|
+
});
|
|
26
|
+
const tool = createSkillsTool({ getLoadedSkills: () => loadedSkills });
|
|
27
|
+
pi.registerTool(tool);
|
|
28
|
+
const registration = await registerSkillsInCodeMode(pi, tool);
|
|
29
|
+
pi.on("session_shutdown", () => {
|
|
30
|
+
registration?.unregister();
|
|
31
|
+
if (sharedState[REGISTRATION_KEY] === owner)
|
|
32
|
+
delete sharedState[REGISTRATION_KEY];
|
|
33
|
+
});
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
async function registerSkillsInCodeMode(
|
|
37
|
+
pi: ExtensionAPI,
|
|
38
|
+
tool: ReturnType<typeof createSkillsTool>,
|
|
39
|
+
) {
|
|
40
|
+
try {
|
|
41
|
+
const { adaptToolForCodeMode, registerCodeModeExtensionTools } =
|
|
42
|
+
await import("@howaboua/pi-codex-conversion/code-mode");
|
|
43
|
+
return registerCodeModeExtensionTools(pi, () => [
|
|
44
|
+
adaptToolForCodeMode(tool, {
|
|
45
|
+
kind: "freeform",
|
|
46
|
+
prepareInput: prepareSkillsCodeModeInput,
|
|
47
|
+
usage:
|
|
48
|
+
'await tools.skills("list") // or "read <skill> [reference-name...]"',
|
|
49
|
+
}),
|
|
50
|
+
]);
|
|
51
|
+
} catch (error) {
|
|
52
|
+
if (isMissingCodeModeExtension(error)) return undefined;
|
|
53
|
+
if (isOutdatedCodeModeExtension(error)) {
|
|
54
|
+
throw new Error(
|
|
55
|
+
"Update " +
|
|
56
|
+
CODE_MODE_PACKAGE +
|
|
57
|
+
" to 3.0.24 or newer to use Better Skills with it",
|
|
58
|
+
{ cause: error },
|
|
59
|
+
);
|
|
60
|
+
}
|
|
61
|
+
throw error;
|
|
62
|
+
}
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
function isMissingCodeModeExtension(error: unknown): boolean {
|
|
66
|
+
if (
|
|
67
|
+
!error ||
|
|
68
|
+
typeof error !== "object" ||
|
|
69
|
+
!("code" in error) ||
|
|
70
|
+
!("message" in error) ||
|
|
71
|
+
typeof error.message !== "string"
|
|
72
|
+
)
|
|
73
|
+
return false;
|
|
74
|
+
if (
|
|
75
|
+
error.code !== "ERR_MODULE_NOT_FOUND" &&
|
|
76
|
+
error.code !== "MODULE_NOT_FOUND"
|
|
77
|
+
)
|
|
78
|
+
return false;
|
|
79
|
+
const missing = error.message.match(
|
|
80
|
+
/Cannot find (?:package|module) ['"]([^'"]+)['"]/,
|
|
81
|
+
)?.[1];
|
|
82
|
+
return missing === CODE_MODE_PACKAGE || missing === CODE_MODE_MODULE;
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
function isOutdatedCodeModeExtension(error: unknown): boolean {
|
|
86
|
+
if (
|
|
87
|
+
!error ||
|
|
88
|
+
typeof error !== "object" ||
|
|
89
|
+
!("code" in error) ||
|
|
90
|
+
!("message" in error) ||
|
|
91
|
+
typeof error.message !== "string"
|
|
92
|
+
)
|
|
93
|
+
return false;
|
|
94
|
+
return (
|
|
95
|
+
(error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED" ||
|
|
96
|
+
error.code === "ERR_UNSUPPORTED_DIR_IMPORT") &&
|
|
97
|
+
(error.message.includes(CODE_MODE_MODULE) ||
|
|
98
|
+
(error.message.includes("Package subpath './code-mode'") &&
|
|
99
|
+
error.message.includes(CODE_MODE_PACKAGE)))
|
|
100
|
+
);
|
|
101
|
+
}
|
package/package.json
ADDED
|
@@ -0,0 +1,76 @@
|
|
|
1
|
+
{
|
|
2
|
+
"name": "@howaboua/pi-better-skills-tool",
|
|
3
|
+
"version": "0.0.1",
|
|
4
|
+
"description": "Progressive skill discovery for Pi, Code Mode and Notebook Mode.",
|
|
5
|
+
"type": "module",
|
|
6
|
+
"license": "MIT",
|
|
7
|
+
"author": "Igor Warzocha",
|
|
8
|
+
"homepage": "https://github.com/IgorWarzocha/howaboua-pi-stuff/tree/main/packages/pi-better-skills-tool#readme",
|
|
9
|
+
"repository": {
|
|
10
|
+
"type": "git",
|
|
11
|
+
"url": "git+https://github.com/IgorWarzocha/howaboua-pi-stuff.git",
|
|
12
|
+
"directory": "packages/pi-better-skills-tool"
|
|
13
|
+
},
|
|
14
|
+
"bugs": {
|
|
15
|
+
"url": "https://github.com/IgorWarzocha/howaboua-pi-stuff/issues"
|
|
16
|
+
},
|
|
17
|
+
"keywords": [
|
|
18
|
+
"pi-package",
|
|
19
|
+
"pi-extension",
|
|
20
|
+
"pi",
|
|
21
|
+
"skills",
|
|
22
|
+
"code-mode"
|
|
23
|
+
],
|
|
24
|
+
"files": [
|
|
25
|
+
"index.ts",
|
|
26
|
+
"src",
|
|
27
|
+
"README.md",
|
|
28
|
+
"LICENSE",
|
|
29
|
+
"CHANGELOG.md",
|
|
30
|
+
"changelog.ts",
|
|
31
|
+
"tsconfig.json",
|
|
32
|
+
"biome.json"
|
|
33
|
+
],
|
|
34
|
+
"scripts": {
|
|
35
|
+
"check": "bun run lint && bun run typecheck && bun run test",
|
|
36
|
+
"prepack": "bun run check",
|
|
37
|
+
"typecheck": "tsgo --noEmit",
|
|
38
|
+
"lint": "biome check .",
|
|
39
|
+
"test": "tsx --test tests/**/*.test.ts",
|
|
40
|
+
"pack:dry": "npm pack --dry-run"
|
|
41
|
+
},
|
|
42
|
+
"peerDependencies": {
|
|
43
|
+
"@howaboua/pi-codex-conversion": ">=3.0.24",
|
|
44
|
+
"@earendil-works/pi-coding-agent": ">=0.84.3",
|
|
45
|
+
"@earendil-works/pi-tui": ">=0.84.3",
|
|
46
|
+
"typebox": "*"
|
|
47
|
+
},
|
|
48
|
+
"peerDependenciesMeta": {
|
|
49
|
+
"@howaboua/pi-codex-conversion": {
|
|
50
|
+
"optional": true
|
|
51
|
+
}
|
|
52
|
+
},
|
|
53
|
+
"devDependencies": {
|
|
54
|
+
"@howaboua/pi-codex-conversion": "3.0.24",
|
|
55
|
+
"@biomejs/biome": "^2.5.10",
|
|
56
|
+
"@earendil-works/pi-coding-agent": "0.84.4",
|
|
57
|
+
"@earendil-works/pi-tui": "0.84.4",
|
|
58
|
+
"@types/node": "^26.2.0",
|
|
59
|
+
"tsx": "^4.23.12",
|
|
60
|
+
"typebox": "1.3.18",
|
|
61
|
+
"typescript": "^7.0.2"
|
|
62
|
+
},
|
|
63
|
+
"pi": {
|
|
64
|
+
"extensions": [
|
|
65
|
+
"./index.ts"
|
|
66
|
+
]
|
|
67
|
+
},
|
|
68
|
+
"engines": {
|
|
69
|
+
"node": ">=22.19.0"
|
|
70
|
+
},
|
|
71
|
+
"main": "index.ts",
|
|
72
|
+
"exports": "./index.ts",
|
|
73
|
+
"publishConfig": {
|
|
74
|
+
"access": "public"
|
|
75
|
+
}
|
|
76
|
+
}
|