@imenam/mcp-dependabot-tracker 1.0.14 → 1.0.15
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/README.md +4 -3
- package/dist/shared/schemas/api.schema.d.ts +24 -5
- package/dist/shared/schemas/ipc.schema.d.ts +1 -1
- package/dist/shared/schemas/ipc.schema.js +1 -0
- package/dist/shared/schemas/model.schema.d.ts +186 -1
- package/dist/shared/schemas/model.schema.js +35 -1
- package/dist/src/core/analysis.d.ts +2 -2
- package/dist/src/core/analysis.js +1 -1
- package/dist/src/core/claude.d.ts +5 -2
- package/dist/src/core/claude.js +22 -12
- package/dist/src/core/operations.d.ts +1 -1
- package/dist/src/core/operations.js +70 -10
- package/dist/src/core/repair.d.ts +2 -2
- package/dist/src/core/repair.js +1 -1
- package/dist/src/core/repos.d.ts +3 -1
- package/dist/src/core/repos.js +19 -0
- package/dist/src/core/store.js +1 -0
- package/dist/src/gui-worker.js +1 -0
- package/dist/src/index.js +6 -1
- package/gui/dist/assets/{index-DETLqB3f.css → index-BftuARjY.css} +1 -1
- package/gui/dist/assets/index-DRo54--Y.js +64 -0
- package/gui/dist/index.html +2 -2
- package/package.json +1 -1
- package/gui/dist/assets/index-D98CR3xl.js +0 -64
package/README.md
CHANGED
|
@@ -214,8 +214,8 @@ Thème sombre, une information par ligne, une action principale par écran.
|
|
|
214
214
|
La roue dentée, à gauche de « Synchroniser maintenant », ouvre les réglages.
|
|
215
215
|
- **Réglages (`#/settings`)** — connexion à l'organizer, token Claude et analyse automatique (voir [L'analyse par Claude](#lanalyse-par-claude)). Un token enregistré n'apparaît que par ses quatre derniers caractères, avec « Remplacer ». « Enregistrer » valide tout l'écran.
|
|
216
216
|
- **Dépréciés (`#/deprecated`)** — les dépôts dépréciés, du plus récent au plus ancien, avec la date de dépréciation. « Rétablir », sur chaque ligne, remet le dépôt dans sa catégorie et relit aussitôt ses alertes. Le chevron ouvre l'écran du dépôt, où « Corriger » est désactivé.
|
|
217
|
-
- **Dépôt (`#/r/<propriétaire>/<nom
|
|
218
|
-
- **Correction (`#/r/<propriétaire>/<nom>/op/<id>`)** — qui l'a lancée (vous ou l'agent), la branche clonée, le périmètre
|
|
217
|
+
- **Dépôt (`#/r/<propriétaire>/<nom>`, `#/r/<propriétaire>/<nom>/history`)** — sélecteur de la branche analysée (un clic ouvre la liste des branches avec un champ de recherche, la branche par défaut en tête ; ↑ ↓ et Entrée ou un clic choisissent, Échap ferme), sélecteur de la catégorie (« Sans catégorie » ou l'une des catégories) et date de la dernière lecture des alertes, puis deux onglets. **Alertes ouvertes**, avec leur nombre : les alertes ouvertes (gravité, paquet, résumé), chacune ouvrant l'alerte sur GitHub. Une alerte dont le paquet n'a aucune version corrigée publiée porte « ⚠ sans correctif », une alerte sur une dépendance de développement l'étiquette « dév. ». Au survol d'une alerte, « Corrigée à la main » la range dans la section « Corrigées à la main », avec la date du marquage ; « Rétablir » la remet à traiter. Dependabot continue souvent de signaler une alerte corrigée à la main (un paquet installé hors du registre npm, par exemple) : la marque tient tant que l'alerte reste ouverte, et tombe à la lecture suivante si Dependabot émet une nouvelle alerte sur le même paquet. **Historique**, avec le nombre d'opérations : une ligne par opération conservée (les 20 dernières du dépôt), de la plus récente à la plus ancienne, avec audit ou correction, qui l'a lancée, le périmètre, la branche, la date, les vulnérabilités avant et après (le début de l'erreur pour une opération échouée), la part de Claude (« analyse », « analyse · 2 passages ») et l'issue (la pull request, « attend le push », « terminée », « annulée », « échouée ») ; chaque ligne ouvre l'opération. « Corriger » lance une correction en production ; la flèche à côté ouvre le choix du périmètre (« Production » ou « Toutes les dépendances », Échap ferme). « Reprendre la correction » rouvre celle en cours. « Agent » ouvre le volet des droits : quatre interrupteurs, enregistrés aussitôt, et « Retirer le dépôt » (un second clic confirme dans les 4 secondes ; refusé pendant une opération).
|
|
218
|
+
- **Correction (`#/r/<propriétaire>/<nom>/op/<id>`)** — qui l'a lancée (vous ou l'agent), la branche clonée, le périmètre ; les flèches « 1 / 5 » passent à l'opération plus récente ou plus ancienne du dépôt, la flèche de retour ramène à son historique. Trois onglets : **Étapes**, **Claude** (quand Claude est intervenu) et **Journal**. Les étapes : celles qui sont faites tiennent sur une ligne avec leur résultat (« 4 vulnérabilités », « 3 corrigées », lien vers la pull request), seule l'étape qui attend une décision est dépliée. Une étape passée en donne la raison : « aucune correction possible » pour `--force` quand npm ne propose aucune montée majeure, « rien à corriger » quand `npm audit fix` a tout corrigé, « rien à pousser » quand les corrections n'ont rien changé, « passé » quand l'utilisateur a passé `--force` (« passé · déconseillé par Claude » après son avis), « ignorée » sinon. Les vulnérabilités sans aucune version corrigée publiée sur le registre npm (`fixAvailable: false`, par exemple `xlsx`, que SheetJS ne publie plus sur npm) sont comptées sur la ligne du dernier audit (« 1 sans correctif ») ; un clic les liste avec leur gravité : leur mise à jour est à faire à la main. Quand Claude analyse les vulnérabilités restantes, l'étape « Analyse par Claude » montre sa durée, ses tours et ses trois dernières actions, puis le lien vers la tâche organizer et un résumé. L'étape `--force` liste les montées majeures avec « Appliquer --force » et « Passer » ; après une analyse, elle donne l'avis de Claude et ce qu'il juge urgent de corriger à la main, et le bouton principal suit sa recommandation. L'étape « Corrections par Claude » affiche les remarques de la tâche, « Commenter la tâche », « Lancer les corrections » et « Passer au push » ; pendant le passage, sa durée, ses tours et les dernières actions de Claude (fichiers modifiés, commandes lancées) ; ensuite, sur sa ligne, les vulnérabilités corrigées et le nombre de fichiers modifiés. L'étape du push montre le message de commit modifiable, le nom de la branche, « voir les changements » (paquets mis à jour, replié) et « Pousser et ouvrir la PR » ; après des corrections par Claude, elle montre d'abord ce qu'il a changé, le nombre de commits de la branche, et « Relancer avec mes remarques ». Une erreur s'affiche sous l'étape qui a échoué. L'onglet « Claude » liste chaque session (l'analyse, puis chaque passage des corrections) avec son heure, sa durée, ses tours et son issue ; la session choisie, la plus récente par défaut, montre les tâches organizer relues, créées ou mises à jour, les remarques que Claude a reçues au lancement, le déroulé complet de ses messages et de ses actions (500 dernières par session), et son résultat : le rapport de l'analyse et l'avis sur `--force`, ou le résumé des corrections, les fichiers modifiés, le commit, les tests et les vulnérabilités restantes ; ou la raison de l'échec. L'onglet « Journal » montre les commandes lancées et leurs résultats ; « Annuler » arrête l'opération.
|
|
219
219
|
|
|
220
220
|
Les écrans se relisent par polling : toutes les 3 s pour les listes, toutes les secondes pendant une opération. Un écran rouvert affiche aussitôt la dernière réponse reçue, puis se met à jour ; seuls les réglages attendent une lecture fraîche.
|
|
221
221
|
|
|
@@ -244,7 +244,8 @@ Deux processus, selon le standard de l'écosystème (`@imenam/mcp-gui-interface`
|
|
|
244
244
|
| `GET /api/categories`, `POST /api/categories` | Catégories dans l'ordre alphabétique ; création (`{ name }`, unique sans tenir compte de la casse). |
|
|
245
245
|
| `PUT` / `DELETE /api/categories/:id` | Renommage (`{ name }`) ; suppression, ses dépôts restant sans catégorie. |
|
|
246
246
|
| `POST /api/repos/:propriétaire/:nom/operations` | Lance une correction sur le périmètre `scope` du corps (`production` ou `all`). |
|
|
247
|
-
| `GET /api/operations
|
|
247
|
+
| `GET /api/repos/:owner/:name/operations` | Historique du dépôt : ses opérations conservées, sans journal ni sessions de Claude. |
|
|
248
|
+
| `GET /api/operations/:id` | Opération, avec les sessions de Claude. |
|
|
248
249
|
| `POST /api/operations/:id/force`, `/repair`, `/push`, `/cancel` | Décision `--force` (`{ apply }`), corrections par Claude lancées, relancées ou passées (`{ run }`), push (`{ commitMessage }`), annulation. |
|
|
249
250
|
| `GET /api/operations/:id/remarks` | Tâche de l'analyse de l'opération et ses commentaires récents, lus sur l'organizer. |
|
|
250
251
|
| `GET /api/settings`, `PUT /api/settings` | Réglages de l'analyse, tokens réduits à leurs quatre derniers caractères ; enregistrement (`{ organizerUrl, organizerToken?, claudeToken?, analysis }`, un token absent est gardé), refusé si la connexion à l'organizer ou le token Claude échoue. |
|
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { z } from "zod";
|
|
2
|
-
import { type AlertSeverity, type AnalysisTask, type AuditScope, type Category, type Operation, type Repo } from "./model.schema.js";
|
|
2
|
+
import { type AlertSeverity, type AnalysisTask, type AuditScope, type Category, type Operation, type Remark, type Repo } from "./model.schema.js";
|
|
3
3
|
/** Corps de `POST /api/repos` : `propriétaire/nom` ou lien GitHub, et la catégorie où le ranger (aucune par défaut). */
|
|
4
4
|
export declare const AddRepoBodySchema: z.ZodObject<{
|
|
5
5
|
repository: z.ZodString;
|
|
@@ -142,11 +142,30 @@ export interface AddableReposResponse {
|
|
|
142
142
|
export interface OperationResponse {
|
|
143
143
|
operation: Operation;
|
|
144
144
|
}
|
|
145
|
-
/**
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
145
|
+
/**
|
|
146
|
+
* Ligne de l'historique d'un dépôt : une opération sans son journal ni le
|
|
147
|
+
* déroulé de ses sessions. `after` est le nombre de vulnérabilités après la
|
|
148
|
+
* dernière étape qui a audité ; `claudeRuns` le nombre de passages des
|
|
149
|
+
* corrections par Claude.
|
|
150
|
+
*/
|
|
151
|
+
export interface OperationSummary {
|
|
152
|
+
id: string;
|
|
153
|
+
kind: Operation["kind"];
|
|
154
|
+
origin: Operation["origin"];
|
|
155
|
+
scope: AuditScope;
|
|
156
|
+
status: Operation["status"];
|
|
157
|
+
baseBranch: string;
|
|
149
158
|
createdAt: string;
|
|
159
|
+
before: number | null;
|
|
160
|
+
after: number | null;
|
|
161
|
+
analysed: boolean;
|
|
162
|
+
claudeRuns: number;
|
|
163
|
+
pullRequest: Operation["pullRequest"];
|
|
164
|
+
error: string | null;
|
|
165
|
+
}
|
|
166
|
+
/** Historique d'un dépôt, de l'opération la plus récente à la plus ancienne. */
|
|
167
|
+
export interface OperationsResponse {
|
|
168
|
+
operations: OperationSummary[];
|
|
150
169
|
}
|
|
151
170
|
/** Tâche de l'analyse d'une opération et ses commentaires récents, du plus ancien au plus récent. */
|
|
152
171
|
export interface RemarksResponse {
|
|
@@ -22,5 +22,5 @@ export declare const IPCMessageSchema: z.ZodObject<{
|
|
|
22
22
|
}, z.core.$strip>;
|
|
23
23
|
export type IPCMessage = z.infer<typeof IPCMessageSchema>;
|
|
24
24
|
/** Requêtes du GUI worker au maître ; chacune reçoit une réponse de même `correlationId`. */
|
|
25
|
-
export declare const GUI_REQUEST_TYPES: readonly ["GET_CONFIG", "LIST_REPOS", "SYNC_REPOS", "GET_AUDIT_ALL", "START_AUDIT_ALL", "LIST_ADDABLE_REPOS", "GET_REPO", "ADD_REPO", "REMOVE_REPO", "DEPRECATE_REPO", "RESTORE_REPO", "SET_RIGHTS", "LIST_BRANCHES", "SET_BRANCH", "SET_CATEGORY", "MARK_ALERT_HANDLED", "UNMARK_ALERT_HANDLED", "LIST_CATEGORIES", "CREATE_CATEGORY", "RENAME_CATEGORY", "DELETE_CATEGORY", "START_FIX", "GET_OPERATION", "DECIDE_FORCE", "DECIDE_REPAIR", "GET_REMARKS", "PUSH_OPERATION", "CANCEL_OPERATION", "GET_SETTINGS", "SAVE_SETTINGS", "TEST_ORGANIZER"];
|
|
25
|
+
export declare const GUI_REQUEST_TYPES: readonly ["GET_CONFIG", "LIST_REPOS", "SYNC_REPOS", "GET_AUDIT_ALL", "START_AUDIT_ALL", "LIST_ADDABLE_REPOS", "GET_REPO", "ADD_REPO", "REMOVE_REPO", "DEPRECATE_REPO", "RESTORE_REPO", "SET_RIGHTS", "LIST_BRANCHES", "SET_BRANCH", "SET_CATEGORY", "MARK_ALERT_HANDLED", "UNMARK_ALERT_HANDLED", "LIST_CATEGORIES", "CREATE_CATEGORY", "RENAME_CATEGORY", "DELETE_CATEGORY", "START_FIX", "GET_OPERATION", "LIST_OPERATIONS", "DECIDE_FORCE", "DECIDE_REPAIR", "GET_REMARKS", "PUSH_OPERATION", "CANCEL_OPERATION", "GET_SETTINGS", "SAVE_SETTINGS", "TEST_ORGANIZER"];
|
|
26
26
|
export type GuiRequestType = (typeof GUI_REQUEST_TYPES)[number];
|
|
@@ -388,6 +388,114 @@ export declare const RepairSchema: z.ZodObject<{
|
|
|
388
388
|
error: z.ZodNullable<z.ZodString>;
|
|
389
389
|
}, z.core.$strip>;
|
|
390
390
|
export type Repair = z.infer<typeof RepairSchema>;
|
|
391
|
+
/** Commentaire d'une tâche organizer : son auteur, son texte et sa date. */
|
|
392
|
+
export declare const RemarkSchema: z.ZodObject<{
|
|
393
|
+
author: z.ZodString;
|
|
394
|
+
body: z.ZodString;
|
|
395
|
+
createdAt: z.ZodString;
|
|
396
|
+
}, z.core.$strip>;
|
|
397
|
+
export type Remark = z.infer<typeof RemarkSchema>;
|
|
398
|
+
export declare const SESSION_KINDS: readonly ["analysis", "repair"];
|
|
399
|
+
export type SessionKind = (typeof SESSION_KINDS)[number];
|
|
400
|
+
export declare const SESSION_OUTCOMES: readonly ["running", "done", "failed", "cancelled"];
|
|
401
|
+
export type SessionOutcome = (typeof SESSION_OUTCOMES)[number];
|
|
402
|
+
/** Ce qu'une session a fait d'une tâche organizer : relue, créée ou mise à jour. */
|
|
403
|
+
export declare const SESSION_TASK_ROLES: readonly ["read", "created", "updated"];
|
|
404
|
+
export type SessionTaskRole = (typeof SESSION_TASK_ROLES)[number];
|
|
405
|
+
/** Élément du déroulé d'une session : message de Claude (`text`) ou appel d'outil en clair (`tool`). */
|
|
406
|
+
export declare const SessionEventSchema: z.ZodObject<{
|
|
407
|
+
kind: z.ZodEnum<{
|
|
408
|
+
text: "text";
|
|
409
|
+
tool: "tool";
|
|
410
|
+
}>;
|
|
411
|
+
text: z.ZodString;
|
|
412
|
+
}, z.core.$strip>;
|
|
413
|
+
export type SessionEvent = z.infer<typeof SessionEventSchema>;
|
|
414
|
+
/**
|
|
415
|
+
* Session de Claude d'une opération, gardée pour l'historique : l'analyse, ou
|
|
416
|
+
* un passage des corrections (`run`, 1 pour l'analyse). `remarks` sont les
|
|
417
|
+
* commentaires de la tâche de l'analyse au lancement des corrections, `tasks`
|
|
418
|
+
* les tâches organizer relues, créées ou mises à jour, `events` le déroulé de
|
|
419
|
+
* la session. Le résultat est le rapport de l'analyse, ou celui des
|
|
420
|
+
* corrections avec leur commit et les vulnérabilités restantes.
|
|
421
|
+
*/
|
|
422
|
+
export declare const ClaudeSessionSchema: z.ZodObject<{
|
|
423
|
+
kind: z.ZodEnum<{
|
|
424
|
+
analysis: "analysis";
|
|
425
|
+
repair: "repair";
|
|
426
|
+
}>;
|
|
427
|
+
run: z.ZodNumber;
|
|
428
|
+
startedAt: z.ZodString;
|
|
429
|
+
endedAt: z.ZodNullable<z.ZodString>;
|
|
430
|
+
turns: z.ZodNumber;
|
|
431
|
+
outcome: z.ZodEnum<{
|
|
432
|
+
cancelled: "cancelled";
|
|
433
|
+
done: "done";
|
|
434
|
+
failed: "failed";
|
|
435
|
+
running: "running";
|
|
436
|
+
}>;
|
|
437
|
+
error: z.ZodNullable<z.ZodString>;
|
|
438
|
+
remarks: z.ZodArray<z.ZodObject<{
|
|
439
|
+
author: z.ZodString;
|
|
440
|
+
body: z.ZodString;
|
|
441
|
+
createdAt: z.ZodString;
|
|
442
|
+
}, z.core.$strip>>;
|
|
443
|
+
tasks: z.ZodArray<z.ZodObject<{
|
|
444
|
+
task: z.ZodObject<{
|
|
445
|
+
key: z.ZodString;
|
|
446
|
+
title: z.ZodString;
|
|
447
|
+
url: z.ZodString;
|
|
448
|
+
status: z.ZodEnum<{
|
|
449
|
+
doing: "doing";
|
|
450
|
+
done: "done";
|
|
451
|
+
review: "review";
|
|
452
|
+
todo: "todo";
|
|
453
|
+
}>;
|
|
454
|
+
}, z.core.$strip>;
|
|
455
|
+
role: z.ZodEnum<{
|
|
456
|
+
created: "created";
|
|
457
|
+
read: "read";
|
|
458
|
+
updated: "updated";
|
|
459
|
+
}>;
|
|
460
|
+
}, z.core.$strip>>;
|
|
461
|
+
events: z.ZodArray<z.ZodObject<{
|
|
462
|
+
kind: z.ZodEnum<{
|
|
463
|
+
text: "text";
|
|
464
|
+
tool: "tool";
|
|
465
|
+
}>;
|
|
466
|
+
text: z.ZodString;
|
|
467
|
+
}, z.core.$strip>>;
|
|
468
|
+
analysisReport: z.ZodNullable<z.ZodObject<{
|
|
469
|
+
summary: z.ZodString;
|
|
470
|
+
urgent: z.ZodArray<z.ZodObject<{
|
|
471
|
+
package: z.ZodString;
|
|
472
|
+
reason: z.ZodString;
|
|
473
|
+
}, z.core.$strip>>;
|
|
474
|
+
force: z.ZodObject<{
|
|
475
|
+
recommended: z.ZodBoolean;
|
|
476
|
+
reason: z.ZodString;
|
|
477
|
+
}, z.core.$strip>;
|
|
478
|
+
}, z.core.$strip>>;
|
|
479
|
+
repairReport: z.ZodNullable<z.ZodObject<{
|
|
480
|
+
summary: z.ZodString;
|
|
481
|
+
changes: z.ZodArray<z.ZodObject<{
|
|
482
|
+
file: z.ZodString;
|
|
483
|
+
change: z.ZodString;
|
|
484
|
+
}, z.core.$strip>>;
|
|
485
|
+
commitMessage: z.ZodString;
|
|
486
|
+
tests: z.ZodObject<{
|
|
487
|
+
outcome: z.ZodEnum<{
|
|
488
|
+
failed: "failed";
|
|
489
|
+
not_run: "not_run";
|
|
490
|
+
passed: "passed";
|
|
491
|
+
}>;
|
|
492
|
+
detail: z.ZodString;
|
|
493
|
+
}, z.core.$strip>;
|
|
494
|
+
}, z.core.$strip>>;
|
|
495
|
+
commit: z.ZodNullable<z.ZodString>;
|
|
496
|
+
remaining: z.ZodNullable<z.ZodNumber>;
|
|
497
|
+
}, z.core.$strip>;
|
|
498
|
+
export type ClaudeSession = z.infer<typeof ClaudeSessionSchema>;
|
|
391
499
|
/**
|
|
392
500
|
* Opération d'audit ou de correction sur un clone temporaire, limitée aux
|
|
393
501
|
* dépendances de `scope`. `workDir` est le
|
|
@@ -395,7 +503,8 @@ export type Repair = z.infer<typeof RepairSchema>;
|
|
|
395
503
|
* qui exécute l'étape en cours. `found` liste les vulnérabilités du premier
|
|
396
504
|
* audit, `remaining` celles qui restent après la dernière étape. `analysis` est
|
|
397
505
|
* l'analyse par Claude, null quand elle n'a pas été lancée ; `repair` ses
|
|
398
|
-
* corrections, null tant qu'elles n'ont pas été lancées
|
|
506
|
+
* corrections, null tant qu'elles n'ont pas été lancées ; `sessions` chaque
|
|
507
|
+
* session de Claude, dans l'ordre.
|
|
399
508
|
*/
|
|
400
509
|
export declare const OperationSchema: z.ZodObject<{
|
|
401
510
|
id: z.ZodString;
|
|
@@ -603,6 +712,82 @@ export declare const OperationSchema: z.ZodObject<{
|
|
|
603
712
|
}, z.core.$strip>>;
|
|
604
713
|
error: z.ZodNullable<z.ZodString>;
|
|
605
714
|
}, z.core.$strip>>;
|
|
715
|
+
sessions: z.ZodArray<z.ZodObject<{
|
|
716
|
+
kind: z.ZodEnum<{
|
|
717
|
+
analysis: "analysis";
|
|
718
|
+
repair: "repair";
|
|
719
|
+
}>;
|
|
720
|
+
run: z.ZodNumber;
|
|
721
|
+
startedAt: z.ZodString;
|
|
722
|
+
endedAt: z.ZodNullable<z.ZodString>;
|
|
723
|
+
turns: z.ZodNumber;
|
|
724
|
+
outcome: z.ZodEnum<{
|
|
725
|
+
cancelled: "cancelled";
|
|
726
|
+
done: "done";
|
|
727
|
+
failed: "failed";
|
|
728
|
+
running: "running";
|
|
729
|
+
}>;
|
|
730
|
+
error: z.ZodNullable<z.ZodString>;
|
|
731
|
+
remarks: z.ZodArray<z.ZodObject<{
|
|
732
|
+
author: z.ZodString;
|
|
733
|
+
body: z.ZodString;
|
|
734
|
+
createdAt: z.ZodString;
|
|
735
|
+
}, z.core.$strip>>;
|
|
736
|
+
tasks: z.ZodArray<z.ZodObject<{
|
|
737
|
+
task: z.ZodObject<{
|
|
738
|
+
key: z.ZodString;
|
|
739
|
+
title: z.ZodString;
|
|
740
|
+
url: z.ZodString;
|
|
741
|
+
status: z.ZodEnum<{
|
|
742
|
+
doing: "doing";
|
|
743
|
+
done: "done";
|
|
744
|
+
review: "review";
|
|
745
|
+
todo: "todo";
|
|
746
|
+
}>;
|
|
747
|
+
}, z.core.$strip>;
|
|
748
|
+
role: z.ZodEnum<{
|
|
749
|
+
created: "created";
|
|
750
|
+
read: "read";
|
|
751
|
+
updated: "updated";
|
|
752
|
+
}>;
|
|
753
|
+
}, z.core.$strip>>;
|
|
754
|
+
events: z.ZodArray<z.ZodObject<{
|
|
755
|
+
kind: z.ZodEnum<{
|
|
756
|
+
text: "text";
|
|
757
|
+
tool: "tool";
|
|
758
|
+
}>;
|
|
759
|
+
text: z.ZodString;
|
|
760
|
+
}, z.core.$strip>>;
|
|
761
|
+
analysisReport: z.ZodNullable<z.ZodObject<{
|
|
762
|
+
summary: z.ZodString;
|
|
763
|
+
urgent: z.ZodArray<z.ZodObject<{
|
|
764
|
+
package: z.ZodString;
|
|
765
|
+
reason: z.ZodString;
|
|
766
|
+
}, z.core.$strip>>;
|
|
767
|
+
force: z.ZodObject<{
|
|
768
|
+
recommended: z.ZodBoolean;
|
|
769
|
+
reason: z.ZodString;
|
|
770
|
+
}, z.core.$strip>;
|
|
771
|
+
}, z.core.$strip>>;
|
|
772
|
+
repairReport: z.ZodNullable<z.ZodObject<{
|
|
773
|
+
summary: z.ZodString;
|
|
774
|
+
changes: z.ZodArray<z.ZodObject<{
|
|
775
|
+
file: z.ZodString;
|
|
776
|
+
change: z.ZodString;
|
|
777
|
+
}, z.core.$strip>>;
|
|
778
|
+
commitMessage: z.ZodString;
|
|
779
|
+
tests: z.ZodObject<{
|
|
780
|
+
outcome: z.ZodEnum<{
|
|
781
|
+
failed: "failed";
|
|
782
|
+
not_run: "not_run";
|
|
783
|
+
passed: "passed";
|
|
784
|
+
}>;
|
|
785
|
+
detail: z.ZodString;
|
|
786
|
+
}, z.core.$strip>;
|
|
787
|
+
}, z.core.$strip>>;
|
|
788
|
+
commit: z.ZodNullable<z.ZodString>;
|
|
789
|
+
remaining: z.ZodNullable<z.ZodNumber>;
|
|
790
|
+
}, z.core.$strip>>;
|
|
606
791
|
error: z.ZodNullable<z.ZodString>;
|
|
607
792
|
log: z.ZodArray<z.ZodObject<{
|
|
608
793
|
at: z.ZodString;
|
|
@@ -187,6 +187,38 @@ export const RepairSchema = z.object({
|
|
|
187
187
|
task: AnalysisTaskSchema.nullable(),
|
|
188
188
|
error: z.string().nullable(),
|
|
189
189
|
});
|
|
190
|
+
/** Commentaire d'une tâche organizer : son auteur, son texte et sa date. */
|
|
191
|
+
export const RemarkSchema = z.object({ author: z.string(), body: z.string(), createdAt: z.string() });
|
|
192
|
+
export const SESSION_KINDS = ["analysis", "repair"];
|
|
193
|
+
export const SESSION_OUTCOMES = ["running", "done", "failed", "cancelled"];
|
|
194
|
+
/** Ce qu'une session a fait d'une tâche organizer : relue, créée ou mise à jour. */
|
|
195
|
+
export const SESSION_TASK_ROLES = ["read", "created", "updated"];
|
|
196
|
+
/** Élément du déroulé d'une session : message de Claude (`text`) ou appel d'outil en clair (`tool`). */
|
|
197
|
+
export const SessionEventSchema = z.object({ kind: z.enum(["text", "tool"]), text: z.string() });
|
|
198
|
+
/**
|
|
199
|
+
* Session de Claude d'une opération, gardée pour l'historique : l'analyse, ou
|
|
200
|
+
* un passage des corrections (`run`, 1 pour l'analyse). `remarks` sont les
|
|
201
|
+
* commentaires de la tâche de l'analyse au lancement des corrections, `tasks`
|
|
202
|
+
* les tâches organizer relues, créées ou mises à jour, `events` le déroulé de
|
|
203
|
+
* la session. Le résultat est le rapport de l'analyse, ou celui des
|
|
204
|
+
* corrections avec leur commit et les vulnérabilités restantes.
|
|
205
|
+
*/
|
|
206
|
+
export const ClaudeSessionSchema = z.object({
|
|
207
|
+
kind: z.enum(SESSION_KINDS),
|
|
208
|
+
run: z.number().int(),
|
|
209
|
+
startedAt: z.string(),
|
|
210
|
+
endedAt: z.string().nullable(),
|
|
211
|
+
turns: z.number().int(),
|
|
212
|
+
outcome: z.enum(SESSION_OUTCOMES),
|
|
213
|
+
error: z.string().nullable(),
|
|
214
|
+
remarks: z.array(RemarkSchema),
|
|
215
|
+
tasks: z.array(z.object({ task: AnalysisTaskSchema, role: z.enum(SESSION_TASK_ROLES) })),
|
|
216
|
+
events: z.array(SessionEventSchema),
|
|
217
|
+
analysisReport: AnalysisReportSchema.nullable(),
|
|
218
|
+
repairReport: RepairReportSchema.nullable(),
|
|
219
|
+
commit: z.string().nullable(),
|
|
220
|
+
remaining: z.number().int().nullable(),
|
|
221
|
+
});
|
|
190
222
|
/**
|
|
191
223
|
* Opération d'audit ou de correction sur un clone temporaire, limitée aux
|
|
192
224
|
* dépendances de `scope`. `workDir` est le
|
|
@@ -194,7 +226,8 @@ export const RepairSchema = z.object({
|
|
|
194
226
|
* qui exécute l'étape en cours. `found` liste les vulnérabilités du premier
|
|
195
227
|
* audit, `remaining` celles qui restent après la dernière étape. `analysis` est
|
|
196
228
|
* l'analyse par Claude, null quand elle n'a pas été lancée ; `repair` ses
|
|
197
|
-
* corrections, null tant qu'elles n'ont pas été lancées
|
|
229
|
+
* corrections, null tant qu'elles n'ont pas été lancées ; `sessions` chaque
|
|
230
|
+
* session de Claude, dans l'ordre.
|
|
198
231
|
*/
|
|
199
232
|
export const OperationSchema = z.object({
|
|
200
233
|
id: z.string(),
|
|
@@ -234,6 +267,7 @@ export const OperationSchema = z.object({
|
|
|
234
267
|
pullRequest: z.object({ number: z.number().int(), url: z.string() }).nullable(),
|
|
235
268
|
analysis: AnalysisSchema.nullable(),
|
|
236
269
|
repair: RepairSchema.nullable(),
|
|
270
|
+
sessions: z.array(ClaudeSessionSchema),
|
|
237
271
|
error: z.string().nullable(),
|
|
238
272
|
log: z.array(LogEntrySchema),
|
|
239
273
|
});
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { type AnalysisReport, type AnalysisTask, type AuditScope, type ForceCandidate, type Operation } from "../../shared/schemas/model.schema.js";
|
|
1
|
+
import { type AnalysisReport, type AnalysisTask, type AuditScope, type ForceCandidate, type Operation, type SessionEvent } from "../../shared/schemas/model.schema.js";
|
|
2
2
|
import type { Settings } from "../../shared/schemas/settings.schema.js";
|
|
3
3
|
import { type ClaudeRuntime } from "./claude.js";
|
|
4
4
|
import { type OrganizerConnection } from "./organizer.js";
|
|
@@ -32,7 +32,7 @@ export interface AnalysisInput {
|
|
|
32
32
|
settings: Settings;
|
|
33
33
|
claude: ClaudeRuntime;
|
|
34
34
|
signal: AbortSignal;
|
|
35
|
-
|
|
35
|
+
onEvent: (event: SessionEvent, turns: number) => void;
|
|
36
36
|
}
|
|
37
37
|
/** Serveur MCP organizer de la session, lancé par `npx` avec le token réglé dans la GUI. */
|
|
38
38
|
export declare function organizerServer(connection: OrganizerConnection): {
|
|
@@ -140,7 +140,7 @@ export async function analyseVulnerabilities(input) {
|
|
|
140
140
|
maxTurns: input.settings.analysis.maxTurns,
|
|
141
141
|
maxMinutes: input.settings.analysis.maxMinutes,
|
|
142
142
|
signal: input.signal,
|
|
143
|
-
|
|
143
|
+
onEvent: input.onEvent,
|
|
144
144
|
}));
|
|
145
145
|
}
|
|
146
146
|
finally {
|
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import type { SessionEvent } from "../../shared/schemas/model.schema.js";
|
|
1
2
|
/**
|
|
2
3
|
* Sessions Claude Code non interactives (`claude -p`, sortie `stream-json`).
|
|
3
4
|
* Claude Code s'authentifie par un token d'abonnement (`claude setup-token`)
|
|
@@ -26,14 +27,16 @@ export interface ClaudeSessionOptions {
|
|
|
26
27
|
maxTurns: number;
|
|
27
28
|
maxMinutes: number;
|
|
28
29
|
signal?: AbortSignal;
|
|
29
|
-
/** Reçoit chaque
|
|
30
|
-
|
|
30
|
+
/** Reçoit chaque élément du déroulé (message de Claude ou appel d'outil) et le nombre de tours écoulés. */
|
|
31
|
+
onEvent?: (event: SessionEvent, turns: number) => void;
|
|
31
32
|
}
|
|
32
33
|
export interface ClaudeSessionResult {
|
|
33
34
|
/** Résultat validé par `--json-schema`, absent sans schéma. */
|
|
34
35
|
structured: unknown;
|
|
35
36
|
turns: number | null;
|
|
36
37
|
}
|
|
38
|
+
/** Ligne d'activité en clair d'un élément du déroulé : sa première ligne, raccourcie. */
|
|
39
|
+
export declare function activityLine(event: SessionEvent): string;
|
|
37
40
|
/**
|
|
38
41
|
* Lance une session et attend sa fin. Les tours sont limités par Claude Code,
|
|
39
42
|
* la durée par le tracker, qui tue alors la session avec ses descendants, comme
|
package/dist/src/core/claude.js
CHANGED
|
@@ -24,6 +24,16 @@ function shorten(text) {
|
|
|
24
24
|
const first = text.trim().split(/\r?\n/)[0];
|
|
25
25
|
return first.length > MAX_LINE ? `${first.slice(0, MAX_LINE)}…` : first;
|
|
26
26
|
}
|
|
27
|
+
/** Taille maximale d'un message de Claude gardé dans le déroulé d'une session. */
|
|
28
|
+
const MAX_MESSAGE = 4000;
|
|
29
|
+
/** Ligne d'activité en clair d'un élément du déroulé : sa première ligne, raccourcie. */
|
|
30
|
+
export function activityLine(event) {
|
|
31
|
+
return shorten(event.text);
|
|
32
|
+
}
|
|
33
|
+
function message(text) {
|
|
34
|
+
const trimmed = text.trim();
|
|
35
|
+
return { kind: "text", text: trimmed.length > MAX_MESSAGE ? `${trimmed.slice(0, MAX_MESSAGE)}…` : trimmed };
|
|
36
|
+
}
|
|
27
37
|
/** Appel d'outil en clair : `Read src/app.ts`, `Grep mermaid`, `Edit src/app.ts`, `$ npm test`, `organizer create_task`. */
|
|
28
38
|
function describeTool(name, input, cwd) {
|
|
29
39
|
const relative = (file) => (typeof file === "string" && path.isAbsolute(file) ? path.relative(cwd, file) || "." : String(file ?? ""));
|
|
@@ -74,7 +84,7 @@ class StreamReader {
|
|
|
74
84
|
}
|
|
75
85
|
catch {
|
|
76
86
|
this.lastText = shorten(line);
|
|
77
|
-
return [
|
|
87
|
+
return [message(line)];
|
|
78
88
|
}
|
|
79
89
|
if (event?.type === "assistant")
|
|
80
90
|
return this.assistant(event.message ?? {});
|
|
@@ -85,22 +95,22 @@ class StreamReader {
|
|
|
85
95
|
}
|
|
86
96
|
return [];
|
|
87
97
|
}
|
|
88
|
-
assistant(
|
|
89
|
-
if (typeof
|
|
90
|
-
this.messages.add(
|
|
98
|
+
assistant(content) {
|
|
99
|
+
if (typeof content.id === "string" && !this.messages.has(content.id)) {
|
|
100
|
+
this.messages.add(content.id);
|
|
91
101
|
this.turns += 1;
|
|
92
102
|
}
|
|
93
|
-
const
|
|
94
|
-
for (const block of Array.isArray(
|
|
103
|
+
const events = [];
|
|
104
|
+
for (const block of Array.isArray(content.content) ? content.content : []) {
|
|
95
105
|
if (block?.type === "text" && typeof block.text === "string" && block.text.trim()) {
|
|
96
106
|
this.lastText = shorten(block.text);
|
|
97
|
-
|
|
107
|
+
events.push(message(block.text));
|
|
98
108
|
}
|
|
99
109
|
else if (block?.type === "tool_use" && typeof block.name === "string") {
|
|
100
|
-
|
|
110
|
+
events.push({ kind: "tool", text: describeTool(block.name, block.input, this.cwd) });
|
|
101
111
|
}
|
|
102
112
|
}
|
|
103
|
-
return
|
|
113
|
+
return events;
|
|
104
114
|
}
|
|
105
115
|
}
|
|
106
116
|
/**
|
|
@@ -149,9 +159,9 @@ export function runClaudeSession(runtime, options) {
|
|
|
149
159
|
stop();
|
|
150
160
|
}, options.maxMinutes * 60_000);
|
|
151
161
|
options.signal?.addEventListener("abort", stop);
|
|
152
|
-
const emit = (
|
|
153
|
-
for (const
|
|
154
|
-
options.
|
|
162
|
+
const emit = (events) => {
|
|
163
|
+
for (const event of events)
|
|
164
|
+
options.onEvent?.(event, reader.turns);
|
|
155
165
|
};
|
|
156
166
|
const finish = (fn) => {
|
|
157
167
|
if (settled)
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
import { type AuditScope, type Operation, type OperationKind } from "../../shared/schemas/model.schema.js";
|
|
2
2
|
import type { Settings } from "../../shared/schemas/settings.schema.js";
|
|
3
|
-
import type
|
|
3
|
+
import { type ClaudeRuntime } from "./claude.js";
|
|
4
4
|
import type { GitHubConfig } from "./config.js";
|
|
5
5
|
import { type Store } from "./store.js";
|
|
6
6
|
/** Accès aux données et à GitHub pour exécuter les opérations. */
|