@agentshouse/kit 0.2.1-cf6a92e13f031 → 0.2.1-cfbadfb5b5e28

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.
Files changed (48) hide show
  1. package/README.md +14 -15
  2. package/dist/acp.js +58 -7
  3. package/dist/afk.js +17 -0
  4. package/dist/agents.js +58 -32
  5. package/dist/authority-main.js +3 -3
  6. package/dist/bridge.js +4 -4
  7. package/dist/building.js +50 -0
  8. package/dist/calls.js +12 -4
  9. package/dist/chunks.js +49 -0
  10. package/dist/clis.js +41 -42
  11. package/dist/connection.js +27 -33
  12. package/dist/content.js +63 -0
  13. package/dist/conversations.js +348 -126
  14. package/dist/copies.js +294 -148
  15. package/dist/end.js +8 -2
  16. package/dist/events.js +742 -210
  17. package/dist/files.js +35 -19
  18. package/dist/git.js +46 -12
  19. package/dist/grok.js +39 -0
  20. package/dist/home.js +0 -7
  21. package/dist/house-cli.js +26 -13
  22. package/dist/house-main.js +3 -3
  23. package/dist/instructions.js +5 -7
  24. package/dist/kit-cli.js +3 -6
  25. package/dist/kit-main.js +3 -3
  26. package/dist/login.js +5 -3
  27. package/dist/logout.js +1 -1
  28. package/dist/mcp.js +2 -0
  29. package/dist/placement.js +10 -18
  30. package/dist/relay.js +21 -0
  31. package/dist/resident.js +47 -32
  32. package/dist/scope.js +12 -4
  33. package/dist/scripts.js +255 -0
  34. package/dist/secret-input.js +1 -1
  35. package/dist/sign-in.js +3 -2
  36. package/dist/silence.js +28 -0
  37. package/dist/skills.js +38 -12
  38. package/dist/transcription.js +37 -25
  39. package/dist/translate.js +18 -9
  40. package/dist/update.js +109 -120
  41. package/dist/wire.js +23 -5
  42. package/dist/work.js +9 -2
  43. package/package.json +18 -17
  44. package/dist/bootstrap.json +0 -24
  45. package/dist/chatgpt.js +0 -32
  46. package/dist/clis-main.js +0 -23
  47. package/dist/parts.js +0 -82
  48. package/dist/web-wizard.js +0 -100
package/dist/resident.js CHANGED
@@ -10,16 +10,17 @@ import { house } from './api.js';
10
10
  import { received } from './bridge.js';
11
11
  import { CONVERSATION_METHODS, Conversations } from './conversations.js';
12
12
  import { LocalCopies } from './copies.js';
13
- import { restart } from './end.js';
14
- import { agentBase, enrolled, forgetRestart, kitHome, ownerLock, ownerSocket, restartAsked } from './home.js';
13
+ import { restart, unknownMethod } from './end.js';
14
+ import { agentBase, enrolled, kitHome, ownerLock, ownerSocket, readEnrolment } from './home.js';
15
15
  import { Calls } from './calls.js';
16
16
  import { killDescendants } from './scope.js';
17
+ import { removeInputs, Scripts } from './scripts.js';
17
18
  import { quoted } from './shell.js';
18
19
  import { SignIns } from './sign-in.js';
19
20
  import { placeSkillSet } from './skills.js';
20
21
  import { holdConnection } from './connection.js';
21
22
  import { KitUpdate } from './update.js';
22
- import { WebWizards } from './web-wizard.js';
23
+ import { takeUnservedRelease } from './wire.js';
23
24
  import { codexLauncher } from './work.js';
24
25
  function report(error) {
25
26
  process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -110,14 +111,7 @@ function connected() {
110
111
  }
111
112
  async function started() {
112
113
  await connected();
113
- await forgetRestart();
114
- watch(kitHome(), () => {
115
- if (enrolled())
116
- return;
117
- killDescendants();
118
- process.exit(1);
119
- });
120
- await placeSkillSet();
114
+ await placeSkillSet((await readEnrolment()).house);
121
115
  await mkdir(agentBase(), { recursive: true });
122
116
  await installShim(join(kitHome(), 'shim', 'git'), 'git-main');
123
117
  await installShim(codexLauncher(), 'codex-main');
@@ -127,6 +121,7 @@ export async function resident() {
127
121
  const copies = new LocalCopies(house);
128
122
  await copies.load();
129
123
  await serveOwner(copies);
124
+ await copies.swept();
130
125
  await started().catch((error) => {
131
126
  report(error);
132
127
  process.exit(1);
@@ -135,17 +130,28 @@ export async function resident() {
135
130
  const agents = new Agents(house, () => changed());
136
131
  let connection = null;
137
132
  let reported = false;
133
+ let stopping = false;
134
+ const stop = async (then) => {
135
+ if (stopping)
136
+ return;
137
+ stopping = true;
138
+ conversations.stopped();
139
+ killDescendants();
140
+ await connection?.close();
141
+ then();
142
+ };
138
143
  const idle = () => calls.idle() && conversations.idle() && agents.idle();
139
144
  const changed = () => {
140
145
  if (!idle()) {
141
146
  reported = false;
142
147
  }
143
- else if (restartAsked() && conversations.quiet()) {
144
- restart('restarting for an updated CLI');
148
+ else if (update.placedRelease() !== null && conversations.quiet()) {
149
+ const placed = update.placedRelease();
150
+ void stop(() => restart(`Kit ${placed} is placed; its supervisor starts it`));
145
151
  }
146
152
  else if (!reported) {
147
153
  reported = true;
148
- logged(house.deliver('/kit/idle', {}, idle));
154
+ logged(house.deliver('/kit/kits/report-idle', {}, idle));
149
155
  }
150
156
  };
151
157
  const calls = new Calls(house, changed);
@@ -154,50 +160,59 @@ export async function resident() {
154
160
  agents,
155
161
  copies,
156
162
  calls,
157
- send: (notification) => connection?.send(notification) ?? false,
163
+ send: (oneWayCall) => connection?.send(oneWayCall) ?? false,
158
164
  changed,
159
165
  });
160
166
  const signIns = new SignIns(house, agents, calls);
161
167
  const update = new KitUpdate(calls);
162
- const wizards = new WebWizards(calls, (notification) => connection?.send(notification) ?? false);
168
+ if (process.env.HOUSE_KIT_SANDBOX !== '1')
169
+ takeUnservedRelease((release) => logged(update.takeRefused(release)));
170
+ removeInputs();
171
+ const scripts = new Scripts(calls, (oneWayCall) => connection?.send(oneWayCall) ?? false);
163
172
  for (const signal of ['SIGTERM', 'SIGINT']) {
164
173
  process.once(signal, () => {
165
- killDescendants();
166
- process.kill(process.pid, signal);
174
+ void stop(() => {
175
+ removeInputs();
176
+ process.kill(process.pid, signal);
177
+ });
167
178
  });
168
179
  }
169
- await house.deliver('/kit/restarted', {}).catch(report);
170
- await update.resumed().catch(report);
180
+ const unenrolled = () => {
181
+ if (!enrolled())
182
+ void stop(() => process.exit(1));
183
+ };
184
+ watch(kitHome(), unenrolled);
185
+ unenrolled();
186
+ await house.deliver('/kit/kits/report-restart', {}).catch(report);
171
187
  logged(agents.refresh());
188
+ agents.keepCurrent(() => process.env.HOUSE_KIT_SANDBOX === '1' && reported);
172
189
  connection = holdConnection({
173
190
  opened: () => {
174
191
  conversations.opened();
175
192
  changed();
176
193
  logged(copies.connected());
177
194
  },
178
- closed: () => wizards.disconnected(),
195
+ closed: () => scripts.disconnected(),
179
196
  call: (call) => {
180
197
  if (call.kind === 'sign_in')
181
198
  signIns.start(call);
182
199
  else if (call.kind === 'update')
183
- update.start(call);
184
- else if (call.kind === 'run_wizard')
185
- wizards.start(call);
200
+ update.take(call);
201
+ else if (call.kind === 'run_wizard' || call.kind === 'run_function')
202
+ scripts.start(call);
186
203
  else if (CONVERSATION_METHODS.has(call.kind))
187
204
  conversations.call(call);
188
205
  else {
189
- const refused = { refused: `This Kit does not know ${call.kind}; update the Kit` };
206
+ const refused = { refused: unknownMethod(call.kind) };
190
207
  void calls.carry(call.input_id, async () => ({ result: refused }));
191
208
  }
192
209
  },
193
- notification: (notification) => {
194
- if (notification.type === 'watching')
195
- conversations.watching(notification.watching === true);
196
- if (notification.type === 'authority_changed')
197
- logged(copies.changed(notification.rooms));
198
- if (notification.type === 'work_available' && notification.subject === 'agents')
210
+ oneWayCall: (oneWayCall) => {
211
+ if (oneWayCall.type === 'watching')
212
+ conversations.watching(oneWayCall.watching === true);
213
+ if (oneWayCall.type === 'work_available' && oneWayCall.subject === 'agents')
199
214
  logged(agents.refresh());
200
- wizards.notified(notification);
215
+ scripts.notified(oneWayCall);
201
216
  },
202
217
  });
203
218
  }
package/dist/scope.js CHANGED
@@ -1,5 +1,5 @@
1
1
  import { execFileSync } from 'node:child_process';
2
- import { mkdirSync, readdirSync, readFileSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
2
+ import { mkdirSync, readdirSync, readFileSync, realpathSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
3
3
  import { join } from 'node:path';
4
4
  const LISTING_BYTES = 1 << 28;
5
5
  const CGROUPS = '/sys/fs/cgroup';
@@ -122,15 +122,23 @@ function members(group) {
122
122
  }
123
123
  return pids;
124
124
  }
125
+ function besideCli(cli) {
126
+ try {
127
+ return `${realpathSync(cli)}-`;
128
+ }
129
+ catch {
130
+ return null;
131
+ }
132
+ }
125
133
  export class Scope {
126
134
  marker;
127
- cli;
135
+ helpers;
128
136
  group;
129
137
  session = null;
130
138
  recorded = null;
131
139
  constructor(marker, name, cli) {
132
140
  this.marker = marker;
133
- this.cli = cli;
141
+ this.helpers = besideCli(cli);
134
142
  const own = ownGroup();
135
143
  this.group = own === null ? null : join(own, name);
136
144
  try {
@@ -168,7 +176,7 @@ export class Scope {
168
176
  return true;
169
177
  if (this.recorded === null)
170
178
  return found.size > 0;
171
- return [...found].some(([pid, { session, command }]) => session !== this.session || !(this.recorded.has(pid) || command.startsWith(`${this.cli}-`)));
179
+ return [...found].some(([pid, { session, command }]) => session !== this.session || !(this.recorded.has(pid) || (this.helpers !== null && command.startsWith(this.helpers))));
172
180
  }
173
181
  empty() {
174
182
  return this.found()?.size === 0;
@@ -0,0 +1,255 @@
1
+ import { spawn as spawnPiped } from 'node:child_process';
2
+ import { randomUUID } from 'node:crypto';
3
+ import { once } from 'node:events';
4
+ import { rmSync } from 'node:fs';
5
+ import { mkdir, rm, writeFile } from 'node:fs/promises';
6
+ import { constants } from 'node:os';
7
+ import { join } from 'node:path';
8
+ import { loginPath, onLoginPath } from './clis.js';
9
+ import { kitHome } from './home.js';
10
+ import { childEnvironment } from './relay.js';
11
+ import { killTree } from './scope.js';
12
+ const TERMINAL = 'xterm-256color';
13
+ const FIRST_SIZE = { cols: 80, rows: 24 };
14
+ const SIGNALLED = 128;
15
+ const NEWLINE = 0x0a;
16
+ const NO_BASH = "bash is not on the login shell's PATH";
17
+ const LOST = { refused: 'the Kit lost its connection to House' };
18
+ function causeOf(error) {
19
+ return error instanceof Error ? error.message : String(error);
20
+ }
21
+ function failed(plan, cause) {
22
+ process.stderr.write(`kit: ${plan.named} could not start: ${cause}\n`);
23
+ return { refused: `the script could not start: ${cause}` };
24
+ }
25
+ function planned(call) {
26
+ if (call.kind === 'run_wizard')
27
+ return { named: 'a Web Wizard', script: call.script, terminal: 'page', function: null };
28
+ return {
29
+ named: 'an Environment function',
30
+ script: call.script,
31
+ terminal: call.terminal ? 'at once' : null,
32
+ function: { input: call.input, timeCap: call.time_cap, outputCap: call.output_cap },
33
+ };
34
+ }
35
+ function inputs() {
36
+ return join(kitHome(), 'inputs');
37
+ }
38
+ async function inputFile(value) {
39
+ await mkdir(inputs(), { recursive: true, mode: 0o700 });
40
+ const path = join(inputs(), `${randomUUID()}.json`);
41
+ await writeFile(path, JSON.stringify(value), { mode: 0o600, flag: 'wx' });
42
+ return path;
43
+ }
44
+ export function removeInputs() {
45
+ rmSync(inputs(), { recursive: true, force: true });
46
+ }
47
+ function struck(line, typed) {
48
+ return typed.some((typedLine) => line.includes(typedLine));
49
+ }
50
+ class KeptOutput {
51
+ cap;
52
+ typedText = '';
53
+ text = '';
54
+ bytes = 0;
55
+ line = '';
56
+ lineBytes = 0;
57
+ dropping = false;
58
+ cut = false;
59
+ constructor(cap) {
60
+ this.cap = cap;
61
+ }
62
+ typed(data) {
63
+ this.typedText += data;
64
+ }
65
+ add(data) {
66
+ const pieces = data.split('\n');
67
+ const rest = pieces.pop();
68
+ for (const piece of pieces)
69
+ this.ended(piece);
70
+ this.extend(rest);
71
+ }
72
+ kept() {
73
+ const typed = this.typedLines(true);
74
+ this.text = [...this.text.split(/(?<=\n)/), this.line].filter((line) => line !== '' && !struck(line, typed)).join('');
75
+ this.bytes = Buffer.byteLength(this.text);
76
+ this.trim();
77
+ return { output: this.text, cut: this.cut };
78
+ }
79
+ typedLines(all) {
80
+ const lines = this.typedText.split(/\r\n|\r|\n/);
81
+ if (!all)
82
+ lines.pop();
83
+ return lines.filter((line) => line !== '');
84
+ }
85
+ ended(piece) {
86
+ const line = `${this.line}${piece}\n`;
87
+ const dropped = this.dropping;
88
+ this.line = '';
89
+ this.lineBytes = 0;
90
+ this.dropping = false;
91
+ if (dropped || struck(line, this.typedLines(false)))
92
+ return;
93
+ this.text += line;
94
+ this.bytes += Buffer.byteLength(line);
95
+ if (this.bytes > 2 * this.cap)
96
+ this.trim();
97
+ }
98
+ extend(piece) {
99
+ if (this.dropping)
100
+ return;
101
+ this.line += piece;
102
+ this.lineBytes += Buffer.byteLength(piece);
103
+ if (this.lineBytes <= this.cap)
104
+ return;
105
+ this.text = '';
106
+ this.bytes = 0;
107
+ this.line = '';
108
+ this.lineBytes = 0;
109
+ this.dropping = true;
110
+ this.cut = true;
111
+ }
112
+ trim() {
113
+ if (this.bytes <= this.cap)
114
+ return;
115
+ const bytes = Buffer.from(this.text);
116
+ const start = bytes.indexOf(NEWLINE, bytes.length - this.cap - 1) + 1;
117
+ this.text = bytes.subarray(start).toString('utf8');
118
+ this.bytes = bytes.length - start;
119
+ this.cut = true;
120
+ }
121
+ }
122
+ export class Scripts {
123
+ calls;
124
+ send;
125
+ runs = new Map();
126
+ constructor(calls, send) {
127
+ this.calls = calls;
128
+ this.send = send;
129
+ }
130
+ start(call) {
131
+ void this.calls.carry(call.input_id, () => this.run(call.input_id, planned(call)));
132
+ }
133
+ notified(oneWayCall) {
134
+ const run = this.runs.get(String(oneWayCall.wizard));
135
+ if (run === undefined)
136
+ return;
137
+ if (oneWayCall.type === 'wizard_input')
138
+ this.typed(run, String(oneWayCall.data));
139
+ if (oneWayCall.type === 'wizard_size')
140
+ this.resized(run, { cols: Number(oneWayCall.cols), rows: Number(oneWayCall.rows) });
141
+ if (oneWayCall.type === 'wizard_end' && run.plan.terminal === 'page')
142
+ this.end(run, {});
143
+ }
144
+ disconnected() {
145
+ for (const run of this.runs.values())
146
+ this.end(run, LOST);
147
+ }
148
+ async run(id, plan) {
149
+ const size = plan.terminal === 'page' ? null : FIRST_SIZE;
150
+ const output = plan.function === null ? null : new KeptOutput(plan.function.outputCap);
151
+ const run = { plan, input: null, output, process: null, pipes: [], terminal: null, size, typed: [], ended: null, sized: Promise.withResolvers() };
152
+ if (size !== null)
153
+ run.sized.resolve();
154
+ this.runs.set(id, run);
155
+ try {
156
+ return { result: await this.ran(id, run), release: plan.function !== null };
157
+ }
158
+ finally {
159
+ this.runs.delete(id);
160
+ if (run.input !== null)
161
+ await rm(run.input, { force: true });
162
+ }
163
+ }
164
+ async ran(id, run) {
165
+ const { plan, output } = run;
166
+ let exited;
167
+ try {
168
+ const { spawn } = await import('@lydell/node-pty');
169
+ const shell = await onLoginPath('bash');
170
+ if (shell === null)
171
+ return failed(plan, NO_BASH);
172
+ const path = await loginPath();
173
+ await run.sized.promise;
174
+ if (plan.function !== null)
175
+ run.input = await inputFile(plan.function.input);
176
+ if (run.ended !== null)
177
+ return run.ended;
178
+ const environment = { ...childEnvironment(), PATH: path, ...(run.input === null ? {} : { HOUSE_INPUT: run.input }) };
179
+ if (plan.terminal === null) {
180
+ ({ exited } = await this.piped(plan.script, shell, environment, run));
181
+ }
182
+ else {
183
+ const terminal = spawn(shell, ['-c', plan.script], { name: TERMINAL, ...run.size, cwd: process.cwd(), env: environment });
184
+ run.process = terminal;
185
+ run.terminal = terminal;
186
+ terminal.onData((data) => {
187
+ this.send({ type: 'wizard_output', wizard: id, data });
188
+ output?.add(data);
189
+ });
190
+ for (const data of run.typed.splice(0))
191
+ terminal.write(data);
192
+ exited = new Promise((resolve) => terminal.onExit(({ exitCode, signal }) => resolve(signal ? SIGNALLED + signal : exitCode)));
193
+ }
194
+ }
195
+ catch (error) {
196
+ return failed(plan, causeOf(error));
197
+ }
198
+ let timedOut = false;
199
+ // House sends a function run's time cap in seconds, and a run still going at its cap ends with its process group and the output pipes it holds.
200
+ const capped = plan.function === null ? undefined : setTimeout(() => {
201
+ timedOut = true;
202
+ this.stop(run);
203
+ }, plan.function.timeCap * 1000);
204
+ const code = await exited;
205
+ clearTimeout(capped);
206
+ if (run.ended !== null)
207
+ return run.ended;
208
+ if (output === null)
209
+ return { exit_code: code };
210
+ const kept = output.kept();
211
+ return timedOut ? { timed_out: true, ...kept } : { exit_code: code, ...kept };
212
+ }
213
+ async piped(script, shell, environment, run) {
214
+ const child = spawnPiped(shell, ['-c', script], { cwd: process.cwd(), env: environment, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
215
+ const exited = new Promise((resolve) => child.once('close', (code, signal) => resolve(signal === null ? code : SIGNALLED + constants.signals[signal])));
216
+ await once(child, 'spawn');
217
+ run.process = { pid: child.pid };
218
+ run.pipes = [child.stdout, child.stderr];
219
+ for (const pipe of run.pipes) {
220
+ pipe.setEncoding('utf8');
221
+ pipe.on('data', (data) => run.output.add(data));
222
+ }
223
+ if (run.ended !== null)
224
+ this.stop(run);
225
+ return { exited };
226
+ }
227
+ typed(run, data) {
228
+ run.output?.typed(data);
229
+ if (run.terminal === null)
230
+ run.typed.push(data);
231
+ else
232
+ run.terminal.write(data);
233
+ }
234
+ resized(run, size) {
235
+ run.size = size;
236
+ run.sized.resolve();
237
+ try {
238
+ run.terminal?.resize(size.cols, size.rows);
239
+ }
240
+ catch { }
241
+ }
242
+ end(run, result) {
243
+ if (run.ended !== null)
244
+ return;
245
+ run.ended = result;
246
+ run.sized.resolve();
247
+ this.stop(run);
248
+ }
249
+ stop(run) {
250
+ if (run.process !== null)
251
+ killTree(run.process);
252
+ for (const pipe of run.pipes)
253
+ pipe.destroy();
254
+ }
255
+ }
@@ -2,7 +2,7 @@ import { finalRefusal, retryDelay } from './api.js';
2
2
  export async function holdSecretInput(house, subject, steps, waiting) {
3
3
  for (let failures = 0; waiting();) {
4
4
  try {
5
- const held = await house.post(`/kit/secret-input/${subject}`, { steps });
5
+ const held = await house.post('/kit/secret-inputs/await', { subject, steps });
6
6
  if (held.outcome === 'collected')
7
7
  return held.content;
8
8
  if (held.release !== 'held')
package/dist/sign-in.js CHANGED
@@ -1,6 +1,7 @@
1
1
  import { spawn } from 'node:child_process';
2
2
  import { createInterface } from 'node:readline';
3
- import { CLIS, withoutProxy } from './clis.js';
3
+ import { CLIS } from './clis.js';
4
+ import { childEnvironment } from './relay.js';
4
5
  import { killTree } from './scope.js';
5
6
  import { holdSecretInput } from './secret-input.js';
6
7
  const ESCAPE = /\u001b\[[\d;]*m/g;
@@ -56,7 +57,7 @@ export class SignIns {
56
57
  const child = spawn(cli, login.args, {
57
58
  stdio: ['pipe', 'pipe', 'pipe'],
58
59
  detached: true,
59
- env: withoutProxy(),
60
+ env: childEnvironment(),
60
61
  });
61
62
  const running = () => child.exitCode === null && child.signalCode === null;
62
63
  const stop = () => killTree(child);
@@ -0,0 +1,28 @@
1
+ const SYSTEM_CLOCK = {
2
+ later: (delay, callback) => setTimeout(callback, delay),
3
+ clear: (timer) => clearTimeout(timer),
4
+ };
5
+ export class Silence {
6
+ timer = null;
7
+ interval;
8
+ silent;
9
+ clock;
10
+ constructor(interval, silent, clock = SYSTEM_CLOCK) {
11
+ this.interval = interval;
12
+ this.silent = silent;
13
+ this.clock = clock;
14
+ }
15
+ heard() {
16
+ this.stop();
17
+ this.timer = this.clock.later(this.interval, () => {
18
+ this.timer = null;
19
+ this.silent();
20
+ });
21
+ }
22
+ stop() {
23
+ if (this.timer === null)
24
+ return;
25
+ this.clock.clear(this.timer);
26
+ this.timer = null;
27
+ }
28
+ }
package/dist/skills.js CHANGED
@@ -1,10 +1,14 @@
1
- import { cp, lstat, mkdir, realpath, rm, symlink } from 'node:fs/promises';
1
+ import { cp, lstat, mkdir, realpath, rm, symlink, writeFile } from 'node:fs/promises';
2
2
  import { homedir } from 'node:os';
3
3
  import { join, relative } from 'node:path';
4
- import { listSkills } from '@agentshouse/skills';
4
+ import { GUIDE, listSkills } from '@agentshouse/skills';
5
+ import { parse } from 'yaml';
5
6
  import { KIT_RELEASE } from './clis.js';
6
7
  import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
7
8
  const RECORD = 'skill-set.json';
9
+ const ENTRY = 'SKILL.md';
10
+ const FRONTMATTER = /^---\n([\s\S]*?)\n---\n/u;
11
+ const ORIGIN = '<origin>';
8
12
  function skillsDirectory() {
9
13
  return join(homedir(), '.agents', 'skills');
10
14
  }
@@ -22,9 +26,31 @@ async function present(path) {
22
26
  throw error;
23
27
  }
24
28
  }
25
- async function install() {
29
+ function skillName(text) {
30
+ const front = FRONTMATTER.exec(text);
31
+ const fields = (front === null ? null : parse(front[1]));
32
+ return typeof fields?.name === 'string' && typeof fields.description === 'string' ? fields.name : undefined;
33
+ }
34
+ function skillSet(origin) {
35
+ const upstream = listSkills().map(({ name, directory }) => ({
36
+ name,
37
+ place: (destination) => cp(directory, destination, { recursive: true }),
38
+ }));
39
+ const pages = GUIDE.flatMap(({ text }) => {
40
+ const name = skillName(text);
41
+ if (name === undefined)
42
+ return [];
43
+ const place = async (destination) => {
44
+ await mkdir(destination);
45
+ await writeFile(join(destination, ENTRY), text.replaceAll(ORIGIN, origin));
46
+ };
47
+ return [{ name, place }];
48
+ });
49
+ return [...upstream, ...pages].sort((left, right) => (left.name < right.name ? -1 : 1));
50
+ }
51
+ async function install(origin) {
26
52
  const placed = [];
27
- for (const skill of listSkills()) {
53
+ for (const skill of skillSet(origin)) {
28
54
  if (!(await present(join(skillsDirectory(), skill.name))) && !(await present(join(claudeDirectory(), skill.name)))) {
29
55
  placed.push(skill);
30
56
  }
@@ -35,32 +61,32 @@ async function install() {
35
61
  await mkdir(claudeDirectory(), { recursive: true });
36
62
  const skills = await realpath(skillsDirectory());
37
63
  const claude = await realpath(claudeDirectory());
38
- for (const { name, directory } of placed) {
39
- await cp(directory, join(skillsDirectory(), name), { recursive: true });
64
+ for (const { name, place } of placed) {
65
+ await place(join(skillsDirectory(), name));
40
66
  if (claude !== skills)
41
67
  await symlink(relative(claude, join(skills, name)), join(claudeDirectory(), name));
42
68
  }
43
- await writeHome(RECORD, { version: KIT_RELEASE, names });
69
+ await writeHome(RECORD, { version: KIT_RELEASE, origin, names });
44
70
  }
45
- export async function placeSkillSet() {
71
+ export async function placeSkillSet(origin) {
46
72
  try {
47
- await replaceSkillSet();
73
+ await replaceSkillSet(origin);
48
74
  }
49
75
  catch (error) {
50
76
  process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
51
77
  }
52
78
  }
53
- async function replaceSkillSet() {
79
+ async function replaceSkillSet(origin) {
54
80
  const accepted = (await readConfiguration()).skills;
55
81
  const installed = await readHome(RECORD);
56
- if (accepted && installed?.version === KIT_RELEASE)
82
+ if (accepted && installed?.version === KIT_RELEASE && installed.origin === origin)
57
83
  return;
58
84
  for (const name of installed?.names ?? []) {
59
85
  await rm(join(claudeDirectory(), name), { recursive: true, force: true });
60
86
  await rm(join(skillsDirectory(), name), { recursive: true, force: true });
61
87
  }
62
88
  if (accepted)
63
- await install();
89
+ await install(origin);
64
90
  else
65
91
  await rm(join(kitHome(), RECORD), { force: true });
66
92
  }