@boboddy/sdk 0.0.7-alpha → 0.0.8-alpha

package/dist/packages/core/src/pipeline-executions/step-execution/entities/step-execution-result-entity.d.ts

@@ -0,0 +1,32 @@
+import type { AnyJsonValue } from "@boboddy/core/common/contracts/json";
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import { StepSignalEntity, type StepSignalEntityProps } from "./step-signal-entity";
+export declare const stepExecutionResultStatusValues: readonly ["succeeded", "failed"];
+export type StepExecutionResultStatus = (typeof stepExecutionResultStatusValues)[number];
+export type StepExecutionResultEntityProps = {
+    id: UuidV7;
+    stepExecutionId: UuidV7;
+    attempt: number;
+    status: StepExecutionResultStatus;
+    resultJson: AnyJsonValue;
+    errorJson?: AnyJsonValue | null | undefined;
+    signals?: readonly StepSignalEntityProps[] | undefined;
+    createdAt?: Date | string | null | undefined;
+};
+export type CreateStepExecutionResultEntityProps = Omit<StepExecutionResultEntityProps, "id"> & {
+    id?: UuidV7 | undefined;
+};
+export declare class StepExecutionResultEntity {
+    readonly id: UuidV7;
+    readonly stepExecutionId: UuidV7;
+    readonly attempt: number;
+    readonly status: StepExecutionResultStatus;
+    readonly resultJson: AnyJsonValue;
+    readonly errorJson: AnyJsonValue | null;
+    readonly signals: StepSignalEntity[];
+    readonly createdAt: Date | null | undefined;
+    private constructor();
+    static create(props: CreateStepExecutionResultEntityProps): StepExecutionResultEntity;
+    static rehydrate(props: StepExecutionResultEntityProps): StepExecutionResultEntity;
+    toJSON(): StepExecutionResultEntityProps;
+}

package/dist/packages/core/src/pipeline-executions/step-execution/entities/step-signal-entity.d.ts

@@ -0,0 +1,36 @@
+import type { AnyJsonValue } from "@boboddy/core/common/contracts/json";
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { SignalExtractorDefinitionType } from "@boboddy/core/pipeline-definitions/step-definition/entities/signal-extractor-definition-entity";
+export declare const stepSignalSourceValues: readonly ["extracted", "computed"];
+export type StepSignalSource = (typeof stepSignalSourceValues)[number];
+export type StepSignalType = SignalExtractorDefinitionType;
+export type StepSignalEntityProps = {
+    id: UuidV7;
+    stepExecutionResultId: UuidV7;
+    key: string;
+    type: StepSignalType;
+    source: StepSignalSource;
+    valueJson: AnyJsonValue;
+    sourcePath?: string | null | undefined;
+    computedFromSignalKeys?: string[] | null | undefined;
+    createdAt?: Date | string | null | undefined;
+};
+export type CreateStepSignalEntityProps = Omit<StepSignalEntityProps, "id"> & {
+    id?: UuidV7 | undefined;
+};
+export declare const inferStepSignalType: (value: AnyJsonValue) => StepSignalType;
+export declare class StepSignalEntity {
+    readonly id: UuidV7;
+    readonly stepExecutionResultId: UuidV7;
+    readonly key: string;
+    readonly type: StepSignalType;
+    readonly source: StepSignalSource;
+    readonly valueJson: AnyJsonValue;
+    readonly sourcePath: string | null;
+    readonly computedFromSignalKeys: string[] | null;
+    readonly createdAt: Date | null | undefined;
+    private constructor();
+    static create(props: CreateStepSignalEntityProps): StepSignalEntity;
+    static rehydrate(props: StepSignalEntityProps): StepSignalEntity;
+    toJSON(): StepSignalEntityProps;
+}

package/dist/packages/core/src/pipeline-executions/step-execution/infra/drizzle-step-execution-repo.d.ts

@@ -0,0 +1,31 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { StepExecutionRepo } from "../application/step-execution-repo";
+import { StepExecutionEntity, type StepExecutionEntityProps } from "../domain/step-execution-entity";
+import { StepExecutionResultEntity, type StepExecutionResultEntityProps } from "../entities/step-execution-result-entity";
+import { StepSignalEntity } from "../entities/step-signal-entity";
+export declare class DrizzleStepExecutionRepo implements StepExecutionRepo {
+    private toEntity;
+    private loadManyFromRows;
+    load(id: StepExecutionEntityProps["id"], dbExecutor?: DbExecutor): Promise<StepExecutionEntity | null>;
+    loadMany(ids: StepExecutionEntityProps["id"][], dbExecutor?: DbExecutor): Promise<(StepExecutionEntity | null)[]>;
+    loadByResultId(stepExecutionResultId: StepExecutionResultEntityProps["id"], dbExecutor?: DbExecutor): Promise<StepExecutionEntity | null>;
+    listByProjectId(projectId: StepExecutionEntityProps["projectId"], dbExecutor?: DbExecutor): Promise<StepExecutionEntity[]>;
+    loadClaimableByProjectId(projectId: StepExecutionEntityProps["projectId"], limit: number, now: Date, dbExecutor?: DbExecutor, workItemId?: string): Promise<StepExecutionEntity[]>;
+    create(stepExecution: StepExecutionEntity, dbExecutor?: DbExecutor): Promise<StepExecutionEntity>;
+    claim(stepExecutionId: StepExecutionEntityProps["id"], claim: {
+        workerId: string;
+        claimToken: string;
+        claimedAt: Date;
+        startedAt: Date;
+        leaseExpiresAt: Date;
+        executionDeadlineAt?: Date | null | undefined;
+    }, dbExecutor?: DbExecutor): Promise<StepExecutionEntity | null>;
+    heartbeat(stepExecutionId: StepExecutionEntityProps["id"], claimToken: string, heartbeat: {
+        lastHeartbeatAt: Date;
+        leaseExpiresAt: Date;
+    }, dbExecutor?: DbExecutor): Promise<StepExecutionEntity | null>;
+    save(stepExecution: StepExecutionEntity, dbExecutor?: DbExecutor): Promise<StepExecutionEntity>;
+    saveMany(stepExecutionEntities: StepExecutionEntity[], dbExecutor?: DbExecutor): Promise<StepExecutionEntity[]>;
+    addResult(stepExecutionResult: StepExecutionResultEntity, dbExecutor?: DbExecutor): Promise<StepExecutionResultEntity>;
+    replaceSignals(stepExecutionResultId: StepExecutionResultEntityProps["id"], signals: StepSignalEntity[], dbExecutor?: DbExecutor): Promise<StepSignalEntity[]>;
+}

package/dist/packages/core/src/projects/project/application/create-project.d.ts

@@ -0,0 +1,13 @@
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { InMemoryDomainEventDispatcher } from "@boboddy/core/lib/domain-events/in-memory-domain-event-dispatcher";
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { ProjectRepo } from "./project-repo";
+import { type CreateProjectInput, type ProjectContract } from "../contracts/project-contracts";
+export declare const createProject: (input: CreateProjectInput, { userId, projectRepo, timeProvider, domainEventDispatcher, dbExecutor, }: {
+    userId: UuidV7;
+    projectRepo: ProjectRepo;
+    timeProvider: TimeProvider;
+    domainEventDispatcher?: InMemoryDomainEventDispatcher | undefined;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<ProjectContract>;

package/dist/packages/core/src/projects/project/application/default-pipelines/default-create-failing-test-step-definition.d.ts

@@ -0,0 +1,4 @@
+import type { CreateStepDefinitionInput } from "@boboddy/core/pipeline-definitions/step-definition/contracts/step-definition-contracts";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+export declare const DEFAULT_CREATE_FAILING_TEST_STEP_KEY = "create_failing_test";
+export declare const buildDefaultCreateFailingTestStepDefinition: (projectId: UuidV7) => CreateStepDefinitionInput;

package/dist/packages/core/src/projects/project/application/default-pipelines/default-description-quality-step-definition.d.ts

@@ -0,0 +1,4 @@
+import type { CreateStepDefinitionInput } from "@boboddy/core/pipeline-definitions/step-definition/contracts/step-definition-contracts";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+export declare const DEFAULT_DESCRIPTION_QUALITY_STEP_KEY = "description_quality_rank";
+export declare const buildDefaultDescriptionQualityStepDefinition: (projectId: UuidV7) => CreateStepDefinitionInput;

package/dist/packages/core/src/projects/project/application/default-pipelines/default-fix-failing-test-step-definition.d.ts

@@ -0,0 +1,4 @@
+import type { CreateStepDefinitionInput } from "@boboddy/core/pipeline-definitions/step-definition/contracts/step-definition-contracts";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+export declare const DEFAULT_FIX_FAILING_TEST_STEP_KEY = "fix_failing_test";
+export declare const buildDefaultFixFailingTestStepDefinition: (projectId: UuidV7) => CreateStepDefinitionInput;

package/dist/packages/core/src/projects/project/application/default-pipelines/default-linear-pipeline-conventions.d.ts

@@ -0,0 +1,9 @@
+export declare const defaultContinuePolicyDefinition: {
+    rulesJson: {
+        rules: [];
+    };
+    defaultEventType: "continue";
+    defaultEventParamsJson: null;
+    allowedEventTypes: ["continue"];
+};
+export declare const DEFAULT_AGENTIC_STEP_TIMEOUT_SECONDS = 1800;

package/dist/packages/core/src/projects/project/application/default-pipelines/default-linear-pipeline-definitions.d.ts

@@ -0,0 +1,7 @@
+import type { CreateLinearPipelineDefinitionInput } from "@boboddy/core/pipeline-definitions/pipeline-definition/contracts/linear-pipeline-definition-contracts";
+import type { StepDefinitionContract } from "@boboddy/core/pipeline-definitions/step-definition/contracts/step-definition-contracts";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+export declare const DEFAULT_DESCRIPTION_QUALITY_PIPELINE_KEY = "description_quality_rank";
+export declare const DEFAULT_CREATE_FAILING_TEST_THEN_FIX_PIPELINE_KEY = "create_failing_test_then_fix";
+export declare const DEFAULT_WEB_REPRO_PLAYWRIGHT_PIPELINE_KEY = "web_repro_playwright";
+export declare const buildDefaultLinearPipelineDefinitions: (projectId: UuidV7, stepDefinitions: readonly StepDefinitionContract[]) => CreateLinearPipelineDefinitionInput[];

package/dist/packages/core/src/projects/project/application/default-pipelines/default-step-definitions.d.ts

@@ -0,0 +1,8 @@
+import type { CreateStepDefinitionInput } from "@boboddy/core/pipeline-definitions/step-definition/contracts/step-definition-contracts";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import { DEFAULT_CREATE_FAILING_TEST_STEP_KEY } from "./default-create-failing-test-step-definition";
+import { DEFAULT_DESCRIPTION_QUALITY_STEP_KEY } from "./default-description-quality-step-definition";
+import { DEFAULT_FIX_FAILING_TEST_STEP_KEY } from "./default-fix-failing-test-step-definition";
+import { DEFAULT_WEB_REPRO_PLAYWRIGHT_STEP_KEY } from "./default-web-repro-playwright-step-definition";
+export { DEFAULT_CREATE_FAILING_TEST_STEP_KEY, DEFAULT_DESCRIPTION_QUALITY_STEP_KEY, DEFAULT_FIX_FAILING_TEST_STEP_KEY, DEFAULT_WEB_REPRO_PLAYWRIGHT_STEP_KEY, };
+export declare const buildDefaultStepDefinitions: (projectId: UuidV7) => CreateStepDefinitionInput[];

package/dist/packages/core/src/projects/project/application/default-pipelines/default-web-repro-playwright-step-definition.d.ts

@@ -0,0 +1,4 @@
+import type { CreateStepDefinitionInput } from "@boboddy/core/pipeline-definitions/step-definition/contracts/step-definition-contracts";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+export declare const DEFAULT_WEB_REPRO_PLAYWRIGHT_STEP_KEY = "web_repro_playwright";
+export declare const buildDefaultWebReproPlaywrightStepDefinition: (projectId: UuidV7) => CreateStepDefinitionInput;

package/dist/packages/core/src/projects/project/application/get-project.d.ts

@@ -0,0 +1,9 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { ProjectRepo } from "./project-repo";
+import { type GetProjectInput, type ProjectContract } from "../contracts/project-contracts";
+export declare const getProject: (input: GetProjectInput, { userId, projectRepo, dbExecutor, }: {
+    userId: UuidV7;
+    projectRepo: ProjectRepo;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<ProjectContract>;

package/dist/packages/core/src/projects/project/application/list-projects.d.ts

@@ -0,0 +1,9 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { ProjectRepo } from "./project-repo";
+import type { ProjectContract } from "../contracts/project-contracts";
+export declare const listProjects: ({ userId, projectRepo, dbExecutor, }: {
+    userId: UuidV7;
+    projectRepo: ProjectRepo;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<ProjectContract[]>;

package/dist/packages/core/src/projects/project/application/project-authorization.d.ts

@@ -0,0 +1,4 @@
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { ProjectEntity } from "../domain/project-entity";
+import { type ProjectPermission } from "../domain/project-permission";
+export declare const assertProjectPermission: (project: ProjectEntity, userId: UuidV7, permission: ProjectPermission) => import("../domain/project-membership").ProjectMembership;

package/dist/packages/core/src/projects/project/application/project-contract-mapper.d.ts

@@ -0,0 +1,3 @@
+import { type ProjectContract } from "../contracts/project-contracts";
+import type { ProjectEntity } from "../domain/project-entity";
+export declare const projectEntityToContract: (project: ProjectEntity) => ProjectContract;

package/dist/packages/core/src/projects/project/application/project-repo.d.ts

@@ -0,0 +1,9 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { ProjectEntity } from "../domain/project-entity";
+export type ProjectRepo = {
+    load(id: UuidV7, dbExecutor?: DbExecutor): Promise<ProjectEntity | null>;
+    listByUser(userId: UuidV7, dbExecutor?: DbExecutor): Promise<ProjectEntity[]>;
+    create(project: ProjectEntity, dbExecutor?: DbExecutor): Promise<ProjectEntity>;
+    save(project: ProjectEntity, dbExecutor?: DbExecutor): Promise<ProjectEntity>;
+};

package/dist/packages/core/src/projects/project/application/seed-default-pipelines-on-project-created.d.ts

@@ -0,0 +1,12 @@
+import type { LinearPipelineDefinitionRepo } from "@boboddy/core/pipeline-definitions/pipeline-definition/application/linear-pipeline-definition-repo";
+import type { StepDefinitionRepo } from "@boboddy/core/pipeline-definitions/step-definition/application/step-definition-repo";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { DomainEventHandler } from "@boboddy/core/lib/domain-events/domain-event";
+import type { ProjectCreatedDomainEvent } from "@boboddy/core/projects/project/domain/project-created.domain-event";
+export declare class SeedDefaultPipelinesOnProjectCreated implements DomainEventHandler<ProjectCreatedDomainEvent> {
+    private readonly stepDefinitionRepo;
+    private readonly linearPipelineDefinitionRepo;
+    private readonly timeProvider;
+    constructor(stepDefinitionRepo: StepDefinitionRepo, linearPipelineDefinitionRepo: LinearPipelineDefinitionRepo, timeProvider: TimeProvider);
+    handle(event: ProjectCreatedDomainEvent, context: Parameters<DomainEventHandler<ProjectCreatedDomainEvent>["handle"]>[1]): Promise<void>;
+}

package/dist/packages/core/src/projects/project/application/update-project-membership.d.ts

@@ -0,0 +1,11 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { ProjectRepo } from "./project-repo";
+import { type ProjectContract, type UpdateProjectMembershipInput } from "../contracts/project-contracts";
+export declare const updateProjectMembership: (input: UpdateProjectMembershipInput, { actorUserId, projectRepo, timeProvider, dbExecutor, }: {
+    actorUserId: UuidV7;
+    projectRepo: ProjectRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+}) => Promise<ProjectContract>;

package/dist/packages/core/src/projects/project/contracts/project-contracts.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+export declare const projectMembershipSchema: z.ZodObject<{
+    userId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    permissions: z.ZodArray<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const projectSchema: z.ZodObject<{
+    id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    gitUrl: z.ZodString;
+    createdByUserId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    memberships: z.ZodArray<z.ZodObject<{
+        userId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+        permissions: z.ZodArray<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const createProjectInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    gitUrl: z.ZodString;
+}, z.core.$strip>;
+export declare const getProjectInputSchema: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+export declare const updateProjectMembershipInputSchema: z.ZodObject<{
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    userId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    permissions: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>;
+}, z.core.$strip>;
+export type ProjectContract = z.infer<typeof projectSchema>;
+export type CreateProjectInput = z.input<typeof createProjectInputSchema>;
+export type GetProjectInput = z.input<typeof getProjectInputSchema>;
+export type UpdateProjectMembershipInput = z.input<typeof updateProjectMembershipInputSchema>;

package/dist/packages/core/src/projects/project/domain/project-created.domain-event.d.ts

@@ -0,0 +1,13 @@
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { DomainEvent } from "@boboddy/core/lib/domain-events/domain-event";
+export declare const PROJECT_CREATED_DOMAIN_EVENT_TYPE = "project.created";
+export type ProjectCreatedDomainEventPayload = {
+    projectId: UuidV7;
+    createdByUserId: UuidV7;
+};
+export declare class ProjectCreatedDomainEvent implements DomainEvent<typeof PROJECT_CREATED_DOMAIN_EVENT_TYPE, ProjectCreatedDomainEventPayload> {
+    readonly payload: ProjectCreatedDomainEventPayload;
+    readonly type = "project.created";
+    readonly occurredAt: Date;
+    constructor(payload: ProjectCreatedDomainEventPayload, occurredAt?: Date);
+}

package/dist/packages/core/src/projects/project/domain/project-entity.d.ts

@@ -0,0 +1,31 @@
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import { ProjectMembership, type ProjectMembershipProps } from "./project-membership";
+export type ProjectEntityProps = {
+    id: UuidV7;
+    name: string;
+    description?: string | null | undefined;
+    gitUrl: string;
+    createdByUserId: UuidV7;
+    memberships: readonly ProjectMembershipProps[];
+    createdAt?: Date | string | null | undefined;
+    updatedAt?: Date | string | null | undefined;
+};
+export type CreateProjectProps = Omit<ProjectEntityProps, "id"> & {
+    id?: UuidV7 | undefined;
+};
+export declare class ProjectEntity {
+    readonly id: UuidV7;
+    readonly name: string;
+    readonly description: string | null;
+    readonly gitUrl: string;
+    readonly createdByUserId: UuidV7;
+    readonly memberships: ProjectMembership[];
+    readonly createdAt: Date | null | undefined;
+    readonly updatedAt: Date | null | undefined;
+    private constructor();
+    static create(props: CreateProjectProps): ProjectEntity;
+    static rehydrate(props: ProjectEntityProps): ProjectEntity;
+    getMembership(userId: UuidV7): ProjectMembership | null;
+    withMembership(membership: ProjectMembership, updatedAt: Date): ProjectEntity;
+    toJSON(): ProjectEntityProps;
+}

package/dist/packages/core/src/projects/project/domain/project-git-url.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export type ProjectGitUrl = string & {
+    readonly __brand: "project-git-url";
+};
+export declare const isProjectGitUrl: (value: string) => boolean;
+export declare const parseProjectGitUrl: (value: string) => ProjectGitUrl;
+export declare const projectGitUrlSchema: z.ZodString;

package/dist/packages/core/src/projects/project/domain/project-membership.d.ts

@@ -0,0 +1,21 @@
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import { type ProjectPermission } from "./project-permission";
+export type ProjectMembershipProps = {
+    projectId: UuidV7;
+    userId: UuidV7;
+    permissions: readonly ProjectPermission[];
+    createdAt?: Date | string | null | undefined;
+    updatedAt?: Date | string | null | undefined;
+};
+export declare class ProjectMembership {
+    readonly projectId: UuidV7;
+    readonly userId: UuidV7;
+    readonly permissions: ProjectPermission[];
+    readonly createdAt: Date | null | undefined;
+    readonly updatedAt: Date | null | undefined;
+    private constructor();
+    static create(props: ProjectMembershipProps): ProjectMembership;
+    static rehydrate(props: ProjectMembershipProps): ProjectMembership;
+    withPermissions(permissions: readonly ProjectPermission[], updatedAt: Date): ProjectMembership;
+    toJSON(): ProjectMembershipProps;
+}

package/dist/packages/core/src/projects/project/domain/project-permission.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const projectPermissionSchema: z.ZodString;
+export declare const projectPermissionListSchema: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>;
+export type ProjectPermission = z.infer<typeof projectPermissionSchema>;
+export declare const parseProjectPermission: (value: string) => ProjectPermission;
+export declare const parseProjectPermissions: (values: readonly string[]) => ProjectPermission[];
+export declare const hasProjectPermission: (permissions: readonly ProjectPermission[], permission: ProjectPermission) => boolean;

package/dist/packages/core/src/projects/project/infra/drizzle-project-repo.d.ts

@@ -0,0 +1,11 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { ProjectRepo } from "../application/project-repo";
+import { ProjectEntity } from "../domain/project-entity";
+export declare class DrizzleProjectRepo implements ProjectRepo {
+    private toEntity;
+    load(id: UuidV7, dbExecutor?: DbExecutor): Promise<ProjectEntity | null>;
+    listByUser(userId: UuidV7, dbExecutor?: DbExecutor): Promise<ProjectEntity[]>;
+    create(project: ProjectEntity, dbExecutor?: DbExecutor): Promise<ProjectEntity>;
+    save(project: ProjectEntity, dbExecutor?: DbExecutor): Promise<ProjectEntity>;
+}

package/dist/packages/core/src/projects/project-context/application/create-project-context-entry.d.ts

@@ -0,0 +1,13 @@
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { AuthorizationService } from "@boboddy/core/access/authorization/application/authorization-service";
+import { type CreateProjectContextEntryInput, type ProjectContextEntryContract } from "../contracts/project-context-entry-contracts";
+import type { ProjectContextEntryRepo } from "./project-context-entry-repo";
+type CreateProjectContextEntryDeps = {
+    userId: UuidV7;
+    authz: AuthorizationService;
+    projectContextEntryRepo: ProjectContextEntryRepo;
+    timeProvider: TimeProvider;
+};
+export declare const createProjectContextEntry: (input: CreateProjectContextEntryInput, deps: CreateProjectContextEntryDeps) => Promise<ProjectContextEntryContract>;
+export {};

package/dist/packages/core/src/projects/project-context/application/delete-project-context-entry.d.ts

@@ -0,0 +1,10 @@
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { AuthorizationService } from "@boboddy/core/access/authorization/application/authorization-service";
+import type { ProjectContextEntryRepo } from "./project-context-entry-repo";
+type DeleteProjectContextEntryDeps = {
+    userId: UuidV7;
+    authz: AuthorizationService;
+    projectContextEntryRepo: ProjectContextEntryRepo;
+};
+export declare const deleteProjectContextEntry: (id: UuidV7, projectId: UuidV7, deps: DeleteProjectContextEntryDeps) => Promise<void>;
+export {};

package/dist/packages/core/src/projects/project-context/application/list-project-context-entries.d.ts

@@ -0,0 +1,13 @@
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+import type { AuthorizationService } from "@boboddy/core/access/authorization/application/authorization-service";
+import { type ProjectContextEntryContract } from "../contracts/project-context-entry-contracts";
+import type { ProjectContextEntryRepo } from "./project-context-entry-repo";
+type ListProjectContextEntriesDeps = {
+    userId: UuidV7;
+    authz: AuthorizationService;
+    projectContextEntryRepo: ProjectContextEntryRepo;
+    timeProvider: TimeProvider;
+};
+export declare const listProjectContextEntries: (projectId: UuidV7, deps: ListProjectContextEntriesDeps) => Promise<ProjectContextEntryContract[]>;
+export {};

package/dist/packages/core/src/projects/project-context/application/project-context-entry-repo.d.ts

@@ -0,0 +1,8 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { ProjectContextEntryEntity } from "../domain/project-context-entry-entity";
+export type ProjectContextEntryRepo = {
+    create(entry: ProjectContextEntryEntity, dbExecutor?: DbExecutor): Promise<ProjectContextEntryEntity>;
+    listByProjectId(projectId: UuidV7, dbExecutor?: DbExecutor): Promise<ProjectContextEntryEntity[]>;
+    delete(id: UuidV7, projectId: UuidV7, dbExecutor?: DbExecutor): Promise<number>;
+};

package/dist/packages/core/src/projects/project-context/contracts/project-context-entry-contracts.d.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+export declare const projectContextEntryCategoryValues: readonly ["persona", "product", "workflows", "glossary", "compliance", "billing", "app-surfaces"];
+export type ProjectContextEntryCategory = (typeof projectContextEntryCategoryValues)[number];
+export declare const projectContextEntrySchema: z.ZodObject<{
+    id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    category: z.ZodEnum<{
+        persona: "persona";
+        product: "product";
+        workflows: "workflows";
+        glossary: "glossary";
+        compliance: "compliance";
+        billing: "billing";
+        "app-surfaces": "app-surfaces";
+    }>;
+    key: z.ZodString;
+    value: z.ZodString;
+    createdByUserId: z.ZodNullable<z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const createProjectContextEntryInputSchema: z.ZodObject<{
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    category: z.ZodEnum<{
+        persona: "persona";
+        product: "product";
+        workflows: "workflows";
+        glossary: "glossary";
+        compliance: "compliance";
+        billing: "billing";
+        "app-surfaces": "app-surfaces";
+    }>;
+    key: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteProjectContextEntryInputSchema: z.ZodObject<{
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+    id: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+}, z.core.$strip>;
+export declare const listProjectContextEntriesInputSchema: z.ZodObject<{
+    projectId: z.ZodString & z.ZodType<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string, z.core.$ZodTypeInternals<import("@boboddy/core/common/contracts/uuid-v7").UuidV7, string>>;
+}, z.core.$strip>;
+export type ProjectContextEntryContract = z.infer<typeof projectContextEntrySchema>;
+export type CreateProjectContextEntryInput = z.input<typeof createProjectContextEntryInputSchema>;
+export type DeleteProjectContextEntryInput = z.input<typeof deleteProjectContextEntryInputSchema>;
+export type ListProjectContextEntriesInput = z.input<typeof listProjectContextEntriesInputSchema>;

package/dist/packages/core/src/projects/project-context/domain/project-context-entry-entity.d.ts

@@ -0,0 +1,27 @@
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+export type ProjectContextEntryEntityProps = {
+    id: UuidV7;
+    projectId: UuidV7;
+    category: string;
+    key: string;
+    value: string;
+    createdByUserId: UuidV7 | null;
+    createdAt: Date | null | undefined;
+    updatedAt: Date | null | undefined;
+};
+export type CreateProjectContextEntryProps = Omit<ProjectContextEntryEntityProps, "id" | "createdAt" | "updatedAt"> & {
+    id?: UuidV7 | undefined;
+};
+export declare class ProjectContextEntryEntity {
+    readonly id: UuidV7;
+    readonly projectId: UuidV7;
+    readonly category: string;
+    readonly key: string;
+    readonly value: string;
+    readonly createdByUserId: UuidV7 | null;
+    readonly createdAt: Date | null | undefined;
+    readonly updatedAt: Date | null | undefined;
+    private constructor();
+    static create(props: CreateProjectContextEntryProps): ProjectContextEntryEntity;
+    static rehydrate(props: ProjectContextEntryEntityProps): ProjectContextEntryEntity;
+}

package/dist/packages/core/src/projects/project-context/infra/drizzle-project-context-entry-repo.d.ts

@@ -0,0 +1,10 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { ProjectContextEntryRepo } from "../application/project-context-entry-repo";
+import { ProjectContextEntryEntity } from "../domain/project-context-entry-entity";
+export declare class DrizzleProjectContextEntryRepo implements ProjectContextEntryRepo {
+    private toEntity;
+    create(entry: ProjectContextEntryEntity, dbExecutor?: DbExecutor): Promise<ProjectContextEntryEntity>;
+    listByProjectId(projectId: UuidV7, dbExecutor?: DbExecutor): Promise<ProjectContextEntryEntity[]>;
+    delete(id: UuidV7, projectId: UuidV7, dbExecutor?: DbExecutor): Promise<number>;
+}

package/dist/packages/core/src/projects/project-opencode-config/application/project-opencode-runtime-metadata.d.ts

@@ -0,0 +1,17 @@
+import type { AnyJsonObject } from "@boboddy/core/common/contracts/json";
+export declare const PROJECT_OPENCODE_RUNTIME_METADATA_KEY = "projectOpencode";
+export type ProjectOpencodeRuntimeDefinitionKind = "command" | "service";
+export type ProjectOpencodeRuntimeMetadata = {
+    definitionKind: ProjectOpencodeRuntimeDefinitionKind;
+    definitionName: string;
+    definitionDescription: string;
+    cwd: string | null;
+};
+export declare const getProjectOpencodeRuntimeMetadata: (metadata: AnyJsonObject) => ProjectOpencodeRuntimeMetadata | null;
+export declare const setProjectOpencodeRuntimeMetadata: (input: {
+    metadata: AnyJsonObject;
+    definitionKind: ProjectOpencodeRuntimeDefinitionKind;
+    definitionName: string;
+    definitionDescription: string;
+    cwd: string | null;
+}) => AnyJsonObject;

package/dist/packages/core/src/work-items/work-item/application/create-work-item.d.ts

@@ -0,0 +1,16 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { AuthorizationService } from "@boboddy/core/access/authorization/application/authorization-service";
+import { type WorkItemContract, type UpsertWorkItemInput, type UpsertWorkItemsInput } from "../contracts/work-item-contracts";
+import type { WorkItemRepo } from "./work-item-repo";
+import type { TimeProvider } from "@boboddy/core/lib/time-provider";
+type CreateWorkItemsDeps = {
+    userId: UuidV7;
+    authz: AuthorizationService;
+    workItemRepo: WorkItemRepo;
+    timeProvider: TimeProvider;
+    dbExecutor?: DbExecutor | undefined;
+};
+export declare const createWorkItems: (input: UpsertWorkItemsInput, deps: CreateWorkItemsDeps) => Promise<WorkItemContract[]>;
+export declare const createWorkItem: (input: UpsertWorkItemInput, deps: CreateWorkItemsDeps) => Promise<WorkItemContract>;
+export {};

package/dist/packages/core/src/work-items/work-item/application/delete-work-items.d.ts

@@ -0,0 +1,14 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { AuthorizationService } from "@boboddy/core/access/authorization/application/authorization-service";
+import type { WorkItemRepo } from "./work-item-repo";
+import { type DeleteWorkItemInput, type DeleteWorkItemsInput } from "../contracts/work-item-contracts";
+type DeleteWorkItemsDeps = {
+    userId: UuidV7;
+    authz: AuthorizationService;
+    workItemRepo: WorkItemRepo;
+    dbExecutor?: DbExecutor;
+};
+export declare const deleteWorkItems: (input: DeleteWorkItemsInput, deps: DeleteWorkItemsDeps) => Promise<number>;
+export declare const deleteWorkItem: (input: DeleteWorkItemInput, deps: DeleteWorkItemsDeps) => Promise<number>;
+export {};

package/dist/packages/core/src/work-items/work-item/application/get-work-items.d.ts

@@ -0,0 +1,14 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import type { UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { AuthorizationService } from "@boboddy/core/access/authorization/application/authorization-service";
+import type { WorkItemRepo } from "./work-item-repo";
+import { type GetWorkItemInput, type GetWorkItemsInput, type WorkItemContract } from "../contracts/work-item-contracts";
+type GetWorkItemsDeps = {
+    userId: UuidV7;
+    authz: AuthorizationService;
+    workItemRepo: WorkItemRepo;
+    dbExecutor?: DbExecutor;
+};
+export declare const getWorkItems: (input: GetWorkItemsInput, deps: GetWorkItemsDeps) => Promise<WorkItemContract[]>;
+export declare const getWorkItem: (input: GetWorkItemInput, deps: GetWorkItemsDeps) => Promise<WorkItemContract>;
+export {};

package/dist/packages/core/src/work-items/work-item/application/list-work-items-by-project.d.ts

@@ -0,0 +1,11 @@
+import type { DbExecutor } from "@boboddy/core/lib/db/db-executor";
+import { type UuidV7 } from "@boboddy/core/common/contracts/uuid-v7";
+import type { WorkItemRepo } from "./work-item-repo";
+import type { ProjectRepo } from "@boboddy/core/projects/project/application/project-repo";
+import type { WorkItemContract } from "../contracts/work-item-contracts";
+export declare const listWorkItemsByProject: (input: string, { userId, projectRepo, workItemRepo, dbExecutor, }: {
+    userId: UuidV7;
+    projectRepo: ProjectRepo;
+    workItemRepo: WorkItemRepo;
+    dbExecutor?: DbExecutor;
+}) => Promise<WorkItemContract[]>;