@imenam/mcp-organizer 0.0.0-stage → 1.0.1

package/dist/shared/schemas/entities.schema.js

@@ -0,0 +1,262 @@
+import { z } from "zod";
+import { AccessLinkPurposeSchema, ActorTypeSchema, AgentOperationSchema, EntityTypeSchema, IdeaOriginSchema, MAX_TASK_DEPTH, MemberRoleSchema, NotificationTypeSchema, RequestKindSchema, RequestStatusSchema, SpaceKindSchema, TaskPrioritySchema, TaskStatusSchema, TaskTypeSchema, TestResultValueSchema, UserStatusSchema, VersionedEntityTypeSchema, } from "./enums.schema.js";
+/** Entités du modèle de données, telles que lues et écrites par le store. */
+export const IdSchema = z.string().min(1);
+export const TimestampSchema = z.iso.datetime();
+/** Adresse e-mail normalisée : rognée et en minuscules. */
+export const EmailSchema = z
+    .string()
+    .trim()
+    .toLowerCase()
+    .pipe(z.email());
+/** Préfixe des numéros de tâche d'un espace (`ORG` dans `ORG-41`). */
+export const KeyPrefixSchema = z.string().regex(/^[A-Z][A-Z0-9]{1,9}$/, "must be 2 to 10 uppercase letters or digits, starting with a letter");
+/** Rang fractionnaire d'un élément dans sa liste ou sa colonne. */
+export const PositionSchema = z.number().finite();
+export const UserSchema = z.object({
+    id: IdSchema,
+    email: EmailSchema,
+    /** Nom affiché, choisi à l'activation : absent tant que le compte est `invited`. */
+    displayName: z.string().min(1).nullable(),
+    passwordHash: z.string().min(1).nullable(),
+    status: UserStatusSchema,
+    createdAt: TimestampSchema,
+});
+export const AccessLinkSchema = z.object({
+    id: IdSchema,
+    userId: IdSchema,
+    purpose: AccessLinkPurposeSchema,
+    /** Invitation qui a émis le lien ; un lien d'invitation n'accepte qu'elle. */
+    invitationId: IdSchema.nullable(),
+    tokenHash: z.string().min(1),
+    expiresAt: TimestampSchema,
+    usedAt: TimestampSchema.nullable(),
+    createdAt: TimestampSchema,
+});
+export const SessionSchema = z.object({
+    idHash: z.string().min(1),
+    userId: IdSchema,
+    createdAt: TimestampSchema,
+    expiresAt: TimestampSchema,
+});
+/**
+ * Jeton d'agent : il couvre un espace dont son propriétaire est membre.
+ * `tokenHash` est le sha256 du jeton, qui n'est jamais stocké en clair ;
+ * `prefix` en garde le début, pour le reconnaître dans la liste.
+ */
+export const AgentTokenSchema = z.object({
+    id: IdSchema,
+    userId: IdSchema,
+    spaceId: IdSchema,
+    name: z.string().trim().min(1),
+    prefix: z.string().min(1),
+    tokenHash: z.string().regex(/^[0-9a-f]{64}$/),
+    createdAt: TimestampSchema,
+    lastUsedAt: TimestampSchema.nullable(),
+    expiresAt: TimestampSchema.nullable(),
+    revokedAt: TimestampSchema.nullable(),
+});
+export const UserSettingsSchema = z.object({
+    userId: IdSchema,
+    notifyAssignApp: z.boolean(),
+    notifyAssignEmail: z.boolean(),
+    notifyCommentApp: z.boolean(),
+    notifyCommentEmail: z.boolean(),
+});
+export const SpaceSchema = z.object({
+    id: IdSchema,
+    name: z.string().trim().min(1),
+    kind: SpaceKindSchema,
+    ownerId: IdSchema,
+    keyPrefix: KeyPrefixSchema,
+    nextTaskNumber: z.number().int().min(1),
+    createdAt: TimestampSchema,
+});
+export const MembershipSchema = z.object({
+    spaceId: IdSchema,
+    userId: IdSchema,
+    role: MemberRoleSchema,
+    joinedAt: TimestampSchema,
+});
+export const InvitationSchema = z.object({
+    id: IdSchema,
+    spaceId: IdSchema,
+    email: EmailSchema,
+    invitedBy: IdSchema,
+    createdAt: TimestampSchema,
+    expiresAt: TimestampSchema,
+    acceptedAt: TimestampSchema.nullable(),
+    revokedAt: TimestampSchema.nullable(),
+    /** Refus de l'invitation par son destinataire. */
+    declinedAt: TimestampSchema.nullable(),
+});
+export const TaskSchema = z.object({
+    id: IdSchema,
+    spaceId: IdSchema,
+    number: z.number().int().min(1),
+    parentId: IdSchema.nullable(),
+    depth: z.number().int().min(0).max(MAX_TASK_DEPTH),
+    type: TaskTypeSchema,
+    title: z.string().trim().min(1),
+    /** Markdown. */
+    description: z.string(),
+    status: TaskStatusSchema,
+    priority: TaskPrioritySchema,
+    position: PositionSchema,
+    /** Tâche que vérifie une tâche de test (même espace, pas elle-même) ; null sinon. */
+    testedTaskId: IdSchema.nullable(),
+    createdBy: IdSchema,
+    createdAt: TimestampSchema,
+    updatedAt: TimestampSchema,
+    version: z.number().int().min(1),
+});
+export const TaskAssigneeSchema = z.object({ taskId: IdSchema, userId: IdSchema });
+export const TagSchema = z.object({ id: IdSchema, spaceId: IdSchema, name: z.string().trim().min(1) });
+export const TaskTagSchema = z.object({ taskId: IdSchema, tagId: IdSchema });
+export const ChecklistItemSchema = z.object({
+    id: IdSchema,
+    taskId: IdSchema,
+    text: z.string().trim().min(1),
+    done: z.boolean(),
+    position: PositionSchema,
+});
+export const TestCheckpointSchema = z.object({
+    id: IdSchema,
+    taskId: IdSchema,
+    text: z.string().trim().min(1),
+    position: PositionSchema,
+});
+export const TestResultSchema = z.object({
+    checkpointId: IdSchema,
+    testerId: IdSchema,
+    result: TestResultValueSchema,
+    comment: z.string(),
+    updatedAt: TimestampSchema,
+});
+export const TestReviewSchema = z.object({
+    id: IdSchema,
+    taskId: IdSchema,
+    testerId: IdSchema,
+    text: z.string(),
+    submittedAt: TimestampSchema.nullable(),
+    requestId: IdSchema.nullable(),
+});
+export const CommentSchema = z.object({
+    id: IdSchema,
+    taskId: IdSchema,
+    authorId: IdSchema,
+    body: z.string().trim().min(1),
+    createdAt: TimestampSchema,
+    editedAt: TimestampSchema.nullable(),
+    /** Demande pour laquelle l'agent a écrit le commentaire, au nom de son auteur ; null pour un commentaire d'utilisateur. */
+    requestId: IdSchema.nullable(),
+});
+export const AttachmentSchema = z.object({
+    id: IdSchema,
+    taskId: IdSchema,
+    uploaderId: IdSchema,
+    filename: z.string().min(1),
+    mime: z.string().min(1),
+    size: z.number().int().min(0),
+    storagePath: z.string().min(1),
+    createdAt: TimestampSchema,
+});
+export const IdeaSchema = z.object({
+    id: IdSchema,
+    spaceId: IdSchema,
+    authorId: IdSchema,
+    text: z.string().trim().min(1),
+    origin: IdeaOriginSchema,
+    requestId: IdSchema.nullable(),
+    promotedTaskId: IdSchema.nullable(),
+    archivedAt: TimestampSchema.nullable(),
+    createdAt: TimestampSchema,
+});
+export const AgentRequestSchema = z.object({
+    id: IdSchema,
+    authorId: IdSchema,
+    /** Espace où la demande est écrite, et où l'agent agit. */
+    targetSpaceId: IdSchema,
+    kind: RequestKindSchema,
+    contextTaskId: IdSchema.nullable(),
+    contextIdeaId: IdSchema.nullable(),
+    text: z.string().trim().min(1),
+    status: RequestStatusSchema,
+    reply: z.string().nullable(),
+    failureReason: z.string().nullable(),
+    createdAt: TimestampSchema,
+    updatedAt: TimestampSchema,
+    claimedAt: TimestampSchema.nullable(),
+    /** Jeton d'agent qui a pris la demande ; seul ce jeton agit pour elle. */
+    claimedByTokenId: IdSchema.nullable(),
+    completedAt: TimestampSchema.nullable(),
+    cancelledBy: IdSchema.nullable(),
+});
+export const AgentActionSchema = z.object({
+    id: IdSchema,
+    requestId: IdSchema,
+    seq: z.number().int().min(1),
+    entityType: EntityTypeSchema,
+    entityId: IdSchema,
+    operation: AgentOperationSchema,
+    before: z.unknown().nullable(),
+    after: z.unknown().nullable(),
+    summary: z.string().min(1),
+    createdAt: TimestampSchema,
+    undoneAt: TimestampSchema.nullable(),
+    undoneBy: IdSchema.nullable(),
+    /** Jeton d'agent qui a fait l'action. */
+    tokenId: IdSchema.nullable(),
+});
+/** Instantané d'une tâche : ses champs, ses assignés et ses tags. */
+export const TaskSnapshotSchema = TaskSchema.extend({
+    assigneeIds: z.array(IdSchema),
+    tagIds: z.array(IdSchema),
+});
+/** Champs d'une tâche que l'historique compare et restaure (assignés et tags compris). */
+export const TASK_RESTORABLE_FIELDS = ["title", "description", "status", "priority", "type", "parentId", "testedTaskId", "assigneeIds", "tagIds"];
+/** Instantané d'une idée. */
+export const IdeaSnapshotSchema = IdeaSchema;
+/**
+ * Version d'une entité versionnée. `snapshot` vaut null pour la version qui
+ * enregistre la suppression. Pour une action de l'agent, `actorId` est le
+ * propriétaire du jeton, au nom de qui l'agent agit, et `tokenId` ce jeton.
+ */
+export const EntityVersionSchema = z.object({
+    entityType: VersionedEntityTypeSchema,
+    entityId: IdSchema,
+    version: z.number().int().min(1),
+    snapshot: z.union([TaskSnapshotSchema, IdeaSnapshotSchema]).nullable(),
+    actorType: ActorTypeSchema,
+    actorId: IdSchema,
+    requestId: IdSchema.nullable(),
+    tokenId: IdSchema.nullable(),
+    createdAt: TimestampSchema,
+});
+export const NotificationSchema = z.object({
+    id: IdSchema,
+    userId: IdSchema,
+    type: NotificationTypeSchema,
+    taskId: IdSchema,
+    actorType: ActorTypeSchema,
+    actorId: IdSchema.nullable(),
+    requestId: IdSchema.nullable(),
+    commentId: IdSchema.nullable(),
+    /** Faux quand le destinataire a désactivé ce type de notification dans l'application : la ligne ne suit alors que l'envoi de l'e-mail. */
+    inApp: z.boolean(),
+    createdAt: TimestampSchema,
+    readAt: TimestampSchema.nullable(),
+    emailedAt: TimestampSchema.nullable(),
+    emailError: z.string().nullable(),
+});
+/** Ligne du journal des changements, lu par le polling de la GUI. */
+export const ChangeSchema = z.object({
+    seq: z.number().int().min(1),
+    spaceId: IdSchema.nullable(),
+    userId: IdSchema.nullable(),
+    entityType: EntityTypeSchema,
+    entityId: IdSchema,
+    /** Tâche concernée : la tâche modifiée, ou celle qui porte l'élément modifié (checklist, commentaire…). */
+    taskId: IdSchema.nullable(),
+    at: TimestampSchema,
+});

package/dist/shared/schemas/enums.schema.d.ts

@@ -0,0 +1,135 @@
+import { z } from "zod";
+/** Valeurs énumérées du modèle de données, partagées par le serveur et la GUI. */
+export declare const USER_STATUSES: readonly ["invited", "active", "disabled"];
+export declare const UserStatusSchema: z.ZodEnum<{
+    active: "active";
+    disabled: "disabled";
+    invited: "invited";
+}>;
+export type UserStatus = z.infer<typeof UserStatusSchema>;
+export declare const ACCESS_LINK_PURPOSES: readonly ["invite", "reset"];
+export declare const AccessLinkPurposeSchema: z.ZodEnum<{
+    invite: "invite";
+    reset: "reset";
+}>;
+export type AccessLinkPurpose = z.infer<typeof AccessLinkPurposeSchema>;
+export declare const SPACE_KINDS: readonly ["personal", "shared"];
+export declare const SpaceKindSchema: z.ZodEnum<{
+    personal: "personal";
+    shared: "shared";
+}>;
+export type SpaceKind = z.infer<typeof SpaceKindSchema>;
+export declare const MEMBER_ROLES: readonly ["owner", "member"];
+export declare const MemberRoleSchema: z.ZodEnum<{
+    member: "member";
+    owner: "owner";
+}>;
+export type MemberRole = z.infer<typeof MemberRoleSchema>;
+export declare const TASK_TYPES: readonly ["standard", "test"];
+export declare const TaskTypeSchema: z.ZodEnum<{
+    standard: "standard";
+    test: "test";
+}>;
+export type TaskType = z.infer<typeof TaskTypeSchema>;
+/** Colonnes du Kanban, dans l'ordre d'affichage. */
+export declare const TASK_STATUSES: readonly ["todo", "doing", "review", "done"];
+export declare const TaskStatusSchema: z.ZodEnum<{
+    doing: "doing";
+    done: "done";
+    review: "review";
+    todo: "todo";
+}>;
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+export declare const TASK_PRIORITIES: readonly ["low", "medium", "high", "critical"];
+export declare const TaskPrioritySchema: z.ZodEnum<{
+    critical: "critical";
+    high: "high";
+    low: "low";
+    medium: "medium";
+}>;
+export type TaskPriority = z.infer<typeof TaskPrioritySchema>;
+/** Profondeur maximale d'une tâche : tâche (0) > sous-tâche (1) > sous-sous-tâche (2). */
+export declare const MAX_TASK_DEPTH = 2;
+export declare const TEST_RESULTS: readonly ["ok", "ko", "blocked", "untested"];
+export declare const TestResultValueSchema: z.ZodEnum<{
+    blocked: "blocked";
+    ko: "ko";
+    ok: "ok";
+    untested: "untested";
+}>;
+export type TestResultValue = z.infer<typeof TestResultValueSchema>;
+export declare const IDEA_ORIGINS: readonly ["manual", "agent"];
+export declare const IdeaOriginSchema: z.ZodEnum<{
+    agent: "agent";
+    manual: "manual";
+}>;
+export type IdeaOrigin = z.infer<typeof IdeaOriginSchema>;
+export declare const REQUEST_KINDS: readonly ["idea", "remark", "test_review", "message", "idea_promotion"];
+export declare const RequestKindSchema: z.ZodEnum<{
+    idea: "idea";
+    idea_promotion: "idea_promotion";
+    message: "message";
+    remark: "remark";
+    test_review: "test_review";
+}>;
+export type RequestKind = z.infer<typeof RequestKindSchema>;
+export declare const REQUEST_STATUSES: readonly ["pending", "processing", "done", "failed", "cancelled"];
+export declare const RequestStatusSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    done: "done";
+    failed: "failed";
+    pending: "pending";
+    processing: "processing";
+}>;
+export type RequestStatus = z.infer<typeof RequestStatusSchema>;
+export declare const AGENT_OPERATIONS: readonly ["create", "update", "delete", "move", "assign"];
+export declare const AgentOperationSchema: z.ZodEnum<{
+    assign: "assign";
+    create: "create";
+    delete: "delete";
+    move: "move";
+    update: "update";
+}>;
+export type AgentOperation = z.infer<typeof AgentOperationSchema>;
+export declare const ACTOR_TYPES: readonly ["user", "agent"];
+export declare const ActorTypeSchema: z.ZodEnum<{
+    agent: "agent";
+    user: "user";
+}>;
+export type ActorType = z.infer<typeof ActorTypeSchema>;
+export declare const NOTIFICATION_TYPES: readonly ["assigned", "comment"];
+export declare const NotificationTypeSchema: z.ZodEnum<{
+    assigned: "assigned";
+    comment: "comment";
+}>;
+export type NotificationType = z.infer<typeof NotificationTypeSchema>;
+/** Types d'entités nommés dans le journal `Change`, les versions et les actions de l'agent. */
+export declare const ENTITY_TYPES: readonly ["user", "user_settings", "space", "membership", "invitation", "task", "tag", "checklist_item", "test_checkpoint", "test_result", "test_review", "comment", "attachment", "idea", "agent_request", "agent_action", "agent_token", "notification"];
+export declare const EntityTypeSchema: z.ZodEnum<{
+    agent_action: "agent_action";
+    agent_request: "agent_request";
+    agent_token: "agent_token";
+    attachment: "attachment";
+    checklist_item: "checklist_item";
+    comment: "comment";
+    idea: "idea";
+    invitation: "invitation";
+    membership: "membership";
+    notification: "notification";
+    space: "space";
+    tag: "tag";
+    task: "task";
+    test_checkpoint: "test_checkpoint";
+    test_result: "test_result";
+    test_review: "test_review";
+    user: "user";
+    user_settings: "user_settings";
+}>;
+export type EntityType = z.infer<typeof EntityTypeSchema>;
+/** Entités dont chaque modification produit une `EntityVersion`. */
+export declare const VERSIONED_ENTITY_TYPES: readonly ["task", "idea"];
+export declare const VersionedEntityTypeSchema: z.ZodEnum<{
+    idea: "idea";
+    task: "task";
+}>;
+export type VersionedEntityType = z.infer<typeof VersionedEntityTypeSchema>;

package/dist/shared/schemas/enums.schema.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+/** Valeurs énumérées du modèle de données, partagées par le serveur et la GUI. */
+export const USER_STATUSES = ["invited", "active", "disabled"];
+export const UserStatusSchema = z.enum(USER_STATUSES);
+export const ACCESS_LINK_PURPOSES = ["invite", "reset"];
+export const AccessLinkPurposeSchema = z.enum(ACCESS_LINK_PURPOSES);
+export const SPACE_KINDS = ["personal", "shared"];
+export const SpaceKindSchema = z.enum(SPACE_KINDS);
+export const MEMBER_ROLES = ["owner", "member"];
+export const MemberRoleSchema = z.enum(MEMBER_ROLES);
+export const TASK_TYPES = ["standard", "test"];
+export const TaskTypeSchema = z.enum(TASK_TYPES);
+/** Colonnes du Kanban, dans l'ordre d'affichage. */
+export const TASK_STATUSES = ["todo", "doing", "review", "done"];
+export const TaskStatusSchema = z.enum(TASK_STATUSES);
+export const TASK_PRIORITIES = ["low", "medium", "high", "critical"];
+export const TaskPrioritySchema = z.enum(TASK_PRIORITIES);
+/** Profondeur maximale d'une tâche : tâche (0) > sous-tâche (1) > sous-sous-tâche (2). */
+export const MAX_TASK_DEPTH = 2;
+export const TEST_RESULTS = ["ok", "ko", "blocked", "untested"];
+export const TestResultValueSchema = z.enum(TEST_RESULTS);
+export const IDEA_ORIGINS = ["manual", "agent"];
+export const IdeaOriginSchema = z.enum(IDEA_ORIGINS);
+export const REQUEST_KINDS = ["idea", "remark", "test_review", "message", "idea_promotion"];
+export const RequestKindSchema = z.enum(REQUEST_KINDS);
+export const REQUEST_STATUSES = ["pending", "processing", "done", "failed", "cancelled"];
+export const RequestStatusSchema = z.enum(REQUEST_STATUSES);
+export const AGENT_OPERATIONS = ["create", "update", "delete", "move", "assign"];
+export const AgentOperationSchema = z.enum(AGENT_OPERATIONS);
+export const ACTOR_TYPES = ["user", "agent"];
+export const ActorTypeSchema = z.enum(ACTOR_TYPES);
+export const NOTIFICATION_TYPES = ["assigned", "comment"];
+export const NotificationTypeSchema = z.enum(NOTIFICATION_TYPES);
+/** Types d'entités nommés dans le journal `Change`, les versions et les actions de l'agent. */
+export const ENTITY_TYPES = [
+    "user",
+    "user_settings",
+    "space",
+    "membership",
+    "invitation",
+    "task",
+    "tag",
+    "checklist_item",
+    "test_checkpoint",
+    "test_result",
+    "test_review",
+    "comment",
+    "attachment",
+    "idea",
+    "agent_request",
+    "agent_action",
+    "agent_token",
+    "notification",
+];
+export const EntityTypeSchema = z.enum(ENTITY_TYPES);
+/** Entités dont chaque modification produit une `EntityVersion`. */
+export const VERSIONED_ENTITY_TYPES = ["task", "idea"];
+export const VersionedEntityTypeSchema = z.enum(VERSIONED_ENTITY_TYPES);

package/dist/shared/schemas/gui-api.schema.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+/**
+ * Nature d'une erreur de l'API de la GUI, qui fixe son code HTTP :
+ * invalid → 400, unauthorized → 401, forbidden → 403, not_found → 404,
+ * conflict → 409, too_large → 413, internal → 500, upstream → 502 (service
+ * externe), unavailable → 503.
+ */
+export declare const API_ERROR_KINDS: readonly ["invalid", "unauthorized", "forbidden", "not_found", "conflict", "too_large", "internal", "upstream", "unavailable"];
+export type ApiErrorKind = (typeof API_ERROR_KINDS)[number];
+/** Requête `/api/*` de la GUI, telle que le serveur web la transmet au routeur de l'API. */
+export interface ApiRequestData {
+    method: string;
+    /** Chemin sous `/api`, par exemple `/health`. */
+    path: string;
+    query: Record<string, string>;
+    body?: unknown;
+    /** Valeur du cookie de session transmise par le navigateur, null sans cookie. */
+    sessionToken: string | null;
+}
+/** Session à poser dans le cookie du navigateur : jeton opaque et fin de validité (ISO 8601). */
+export interface SessionCookie {
+    token: string;
+    expiresAt: string;
+}
+/** Fichier renvoyé tel quel au navigateur (téléchargement d'une pièce jointe). */
+export interface ApiFile {
+    contentBase64: string;
+    mime: string;
+    filename: string;
+}
+/**
+ * Réponse du routeur de l'API à une requête `/api/*`. `session` pose (ou
+ * prolonge) le cookie de session ; `null` l'efface ; absent, le cookie est
+ * laissé tel quel. Avec `file`, le serveur web renvoie ce fichier au lieu du
+ * corps JSON.
+ */
+export interface ApiResponseData {
+    body: unknown;
+    session?: SessionCookie | null;
+    file?: ApiFile;
+}
+/** En-tête posé sur une erreur relayée d'un service externe : un 401 de Groq ne ferme pas la session. */
+export declare const UPSTREAM_ERROR_HEADER = "X-Organizer-Error-Source";
+/** Nom du cookie de session de la GUI. */
+export declare const SESSION_COOKIE_NAME = "organizer_session";
+/** Réponse de `GET /api/health`. */
+export declare const HealthResponseSchema: z.ZodObject<{
+    status: z.ZodLiteral<"ok">;
+    version: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    accountsExist: z.ZodBoolean;
+}, z.core.$strip>;
+export type HealthResponse = z.infer<typeof HealthResponseSchema>;

package/dist/shared/schemas/gui-api.schema.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+/**
+ * Nature d'une erreur de l'API de la GUI, qui fixe son code HTTP :
+ * invalid → 400, unauthorized → 401, forbidden → 403, not_found → 404,
+ * conflict → 409, too_large → 413, internal → 500, upstream → 502 (service
+ * externe), unavailable → 503.
+ */
+export const API_ERROR_KINDS = ["invalid", "unauthorized", "forbidden", "not_found", "conflict", "too_large", "internal", "upstream", "unavailable"];
+/** En-tête posé sur une erreur relayée d'un service externe : un 401 de Groq ne ferme pas la session. */
+export const UPSTREAM_ERROR_HEADER = "X-Organizer-Error-Source";
+/** Nom du cookie de session de la GUI. */
+export const SESSION_COOKIE_NAME = "organizer_session";
+/** Réponse de `GET /api/health`. */
+export const HealthResponseSchema = z.object({
+    status: z.literal("ok"),
+    version: z.string(),
+    schemaVersion: z.number().int(),
+    /** Faux tant qu'aucun compte n'existe : la connexion est alors impossible. */
+    accountsExist: z.boolean(),
+});

package/dist/shared/schemas/ideas-api.schema.d.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+/** Corps des requêtes et des réponses de la boîte à idées de la GUI. */
+export declare const MAX_IDEA_LENGTH = 5000;
+export declare const IdeaTextSchema: z.ZodString;
+/** Idée telle que l'affiche la page Idées. */
+export declare const IdeaViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+    origin: z.ZodEnum<{
+        agent: "agent";
+        manual: "manual";
+    }>;
+    authorId: z.ZodString;
+    authorName: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    promotedTask: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        key: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>>;
+    pendingPromotion: z.ZodNullable<z.ZodObject<{
+        requestId: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            processing: "processing";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type IdeaView = z.infer<typeof IdeaViewSchema>;
+export declare const IdeaListResponseSchema: z.ZodObject<{
+    ideas: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        origin: z.ZodEnum<{
+            agent: "agent";
+            manual: "manual";
+        }>;
+        authorId: z.ZodString;
+        authorName: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        archivedAt: z.ZodNullable<z.ZodISODateTime>;
+        promotedTask: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            key: z.ZodString;
+            title: z.ZodString;
+        }, z.core.$strip>>;
+        pendingPromotion: z.ZodNullable<z.ZodObject<{
+            requestId: z.ZodString;
+            status: z.ZodEnum<{
+                pending: "pending";
+                processing: "processing";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    activeCount: z.ZodNumber;
+}, z.core.$strip>;
+export type IdeaListResponse = z.infer<typeof IdeaListResponseSchema>;
+export declare const CreateIdeaRequestSchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strip>;
+export type CreateIdeaRequest = z.infer<typeof CreateIdeaRequestSchema>;
+export declare const UpdateIdeaRequestSchema: z.ZodObject<{
+    archived: z.ZodBoolean;
+}, z.core.$strip>;
+export type UpdateIdeaRequest = z.infer<typeof UpdateIdeaRequestSchema>;
+/** Promotion manuelle : la tâche créée en colonne « À faire », avec l'idée pour description. */
+export declare const PromoteIdeaRequestSchema: z.ZodObject<{
+    title: z.ZodString;
+    type: z.ZodEnum<{
+        standard: "standard";
+        test: "test";
+    }>;
+    priority: z.ZodEnum<{
+        critical: "critical";
+        high: "high";
+        low: "low";
+        medium: "medium";
+    }>;
+}, z.core.$strip>;
+export type PromoteIdeaRequest = z.infer<typeof PromoteIdeaRequestSchema>;

package/dist/shared/schemas/ideas-api.schema.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { IdeaOriginSchema, TaskPrioritySchema, TaskTypeSchema } from "./enums.schema.js";
+import { IdSchema, TimestampSchema } from "./entities.schema.js";
+import { TaskRefSchema, TaskTitleSchema } from "./tasks-api.schema.js";
+/** Corps des requêtes et des réponses de la boîte à idées de la GUI. */
+export const MAX_IDEA_LENGTH = 5_000;
+export const IdeaTextSchema = z
+    .string()
+    .trim()
+    .min(1, "L'idée est vide : écrivez-la avant de l'ajouter.")
+    .max(MAX_IDEA_LENGTH, `L'idée dépasse ${MAX_IDEA_LENGTH} caractères.`);
+/** Idée telle que l'affiche la page Idées. */
+export const IdeaViewSchema = z.object({
+    id: IdSchema,
+    text: z.string(),
+    /** `agent` pour une idée classée par l'agent dans la boîte. */
+    origin: IdeaOriginSchema,
+    authorId: IdSchema,
+    authorName: z.string(),
+    createdAt: TimestampSchema,
+    archivedAt: TimestampSchema.nullable(),
+    /** Tâche issue de l'idée, si elle a été promue et que la tâche existe. */
+    promotedTask: TaskRefSchema.nullable(),
+    /** Promotion confiée à l'agent, en attente ou en cours de traitement. */
+    pendingPromotion: z.object({ requestId: IdSchema, status: z.enum(["pending", "processing"]) }).nullable(),
+});
+export const IdeaListResponseSchema = z.object({
+    /** Idées de l'espace, de la plus récente à la plus ancienne : actives, archivées et promues. */
+    ideas: z.array(IdeaViewSchema),
+    /** Idées ni archivées ni promues. */
+    activeCount: z.number().int().min(0),
+});
+export const CreateIdeaRequestSchema = z.object({ text: IdeaTextSchema });
+export const UpdateIdeaRequestSchema = z.object({ archived: z.boolean() });
+/** Promotion manuelle : la tâche créée en colonne « À faire », avec l'idée pour description. */
+export const PromoteIdeaRequestSchema = z.object({
+    title: TaskTitleSchema,
+    type: TaskTypeSchema,
+    priority: TaskPrioritySchema,
+});