@shepai/cli 1.2.0 → 1.3.0

package/dist/src/domain/generated/output.d.ts

@@ -0,0 +1,717 @@
+export type UUID = string;
+/**
+ * Base model providing identity and timestamp fields for all domain entities
+ */
+export type BaseEntity = {
+    /**
+     * Unique identifier for this entity (UUID v4 format)
+     */
+    id: UUID;
+    /**
+     * Timestamp when this entity was created (read-only, set by system)
+     */
+    createdAt: any;
+    /**
+     * Timestamp when this entity was last updated (read-only, set by system)
+     */
+    updatedAt: any;
+};
+/**
+ * Entity that supports soft deletion with a deletedAt timestamp
+ */
+export type SoftDeletableEntity = BaseEntity & {
+    /**
+     * Timestamp when this entity was soft-deleted (null if not deleted)
+     */
+    deletedAt?: any;
+};
+/**
+ * Entity with audit trail tracking who created and modified it
+ */
+export type AuditableEntity = BaseEntity & {
+    /**
+     * UUID of the user who created this entity (null for system-created)
+     */
+    createdBy?: UUID;
+    /**
+     * UUID of the user who last updated this entity (null for system-updated)
+     */
+    updatedBy?: UUID;
+};
+/**
+ * Request model for conversational AI interactions
+ */
+export type AskRequest = {
+    /**
+     * The natural language query to be processed by the AI agent
+     */
+    query: string;
+};
+/**
+ * Response model for conversational AI interactions
+ */
+export type AskResponse = {
+    /**
+     * The AI-generated response content (typically Markdown-formatted)
+     */
+    content: string;
+    /**
+     * Whether the operation completed successfully
+     */
+    success: boolean;
+};
+/**
+ * Acceptance criterion for validating completion of an action item
+ */
+export type AcceptanceCriteria = BaseEntity & {
+    /**
+     * Description of what must be true for this criterion to be satisfied
+     */
+    description: string;
+    /**
+     * Whether this criterion has been verified as complete
+     */
+    verified: boolean;
+};
+/**
+ * Granular, atomic step within a Task representing a single unit of work
+ */
+export type ActionItem = BaseEntity & {
+    /**
+     * Short name describing the action (verb-noun pattern recommended)
+     */
+    name: string;
+    /**
+     * Detailed description of the work to be performed
+     */
+    description: string;
+    /**
+     * Git branch name where this action item's work is performed
+     */
+    branch: string;
+    /**
+     * Action items that must complete before this one can start
+     */
+    dependsOn: ActionItem[];
+    /**
+     * Acceptance criteria for verifying completion of this action item
+     */
+    acceptanceCriteria: AcceptanceCriteria[];
+};
+export declare enum ArtifactCategory {
+    PRD = "PRD",
+    API = "API",
+    Design = "Design",
+    Other = "Other"
+}
+export declare enum ArtifactFormat {
+    Markdown = "md",
+    Text = "txt",
+    Yaml = "yaml",
+    Other = "Other"
+}
+export declare enum ArtifactState {
+    Todo = "Todo",
+    Elaborating = "Elaborating",
+    Done = "Done"
+}
+/**
+ * Generated document or file attached to a Feature
+ */
+export type Artifact = BaseEntity & {
+    /**
+     * Human-readable name identifying this artifact
+     */
+    name: string;
+    /**
+     * Type description providing additional context (e.g., 'documentation', 'api-spec')
+     */
+    type: string;
+    /**
+     * Category classification (PRD, API, Design, or Other)
+     */
+    category: ArtifactCategory;
+    /**
+     * File format for the artifact content
+     */
+    format: ArtifactFormat;
+    /**
+     * Brief summary of the artifact's content and purpose
+     */
+    summary: string;
+    /**
+     * Relative file path where the artifact is stored
+     */
+    path: string;
+    /**
+     * Current state in the artifact generation lifecycle
+     */
+    state: ArtifactState;
+};
+export declare enum MessageRole {
+    Assistant = "assistant",
+    User = "user"
+}
+/**
+ * A message in a conversation thread between user and AI assistant
+ */
+export type Message = BaseEntity & {
+    /**
+     * Role of the message sender (User or Assistant)
+     */
+    role: MessageRole;
+    /**
+     * The text content of the message
+     */
+    content: string;
+    /**
+     * Optional choices presented to the user for selection
+     */
+    options?: string[];
+    /**
+     * Optional user's freeform text answer
+     */
+    answer?: string;
+    /**
+     * Optional index of the selected option from the options array (0-based)
+     */
+    selectedOption?: number;
+};
+export declare enum RequirementType {
+    Functional = "Functional",
+    NonFunctional = "NonFunctional"
+}
+export declare enum ResearchState {
+    NotStarted = "NotStarted",
+    Running = "Running",
+    Finished = "Finished"
+}
+/**
+ * A research topic exploration for gathering technical information
+ */
+export type Research = BaseEntity & {
+    /**
+     * The topic or subject being researched
+     */
+    topic: string;
+    /**
+     * Current state of the research activity (NotStarted, Running, Finished)
+     */
+    state: ResearchState;
+    /**
+     * Summary of research findings and recommendations
+     */
+    summary: string;
+    /**
+     * Artifacts produced during the research activity
+     */
+    artifacts: Artifact[];
+};
+/**
+ * A user or inferred requirement attached to a feature
+ */
+export type Requirement = BaseEntity & {
+    /**
+     * URL-friendly short identifier for the requirement
+     */
+    slug: string;
+    /**
+     * The original user query that generated this requirement
+     */
+    userQuery: string;
+    /**
+     * Classification type of the requirement (Functional or NonFunctional)
+     */
+    type: RequirementType;
+    /**
+     * Research activities conducted to clarify or validate this requirement
+     */
+    researches: Research[];
+};
+/**
+ * AI model configuration for different SDLC agents
+ */
+export type ModelConfiguration = {
+    /**
+     * Model for codebase analysis agent
+     */
+    analyze: string;
+    /**
+     * Model for requirements gathering agent
+     */
+    requirements: string;
+    /**
+     * Model for planning agent
+     */
+    plan: string;
+    /**
+     * Model for implementation agent
+     */
+    implement: string;
+};
+/**
+ * User profile information
+ */
+export type UserProfile = {
+    /**
+     * User's display name (optional)
+     */
+    name?: string;
+    /**
+     * User's email address (optional)
+     */
+    email?: string;
+    /**
+     * GitHub username (optional, for PR attribution)
+     */
+    githubUsername?: string;
+};
+/**
+ * Environment and tooling preferences
+ */
+export type EnvironmentConfig = {
+    /**
+     * Preferred code editor
+     */
+    defaultEditor: string;
+    /**
+     * Preferred shell
+     */
+    shellPreference: string;
+};
+/**
+ * System configuration
+ */
+export type SystemConfig = {
+    /**
+     * CLI auto-update preference
+     */
+    autoUpdate: boolean;
+    /**
+     * Log level for CLI output
+     */
+    logLevel: string;
+};
+/**
+ * Global Shep platform settings (singleton)
+ */
+export type Settings = BaseEntity & {
+    /**
+     * AI model configuration for different agents
+     */
+    models: ModelConfiguration;
+    /**
+     * User profile information
+     */
+    user: UserProfile;
+    /**
+     * Environment and tooling preferences
+     */
+    environment: EnvironmentConfig;
+    /**
+     * System-level parameters
+     */
+    system: SystemConfig;
+};
+export declare enum TaskState {
+    Todo = "Todo",
+    WIP = "Work in Progress",
+    Done = "Done",
+    Review = "Review"
+}
+/**
+ * A discrete unit of work within an implementation plan
+ */
+export type Task = BaseEntity & {
+    /**
+     * Optional human-readable title for the task
+     */
+    title?: string;
+    /**
+     * Optional detailed description of what the task entails
+     */
+    description?: string;
+    /**
+     * Tasks that must be completed before this task can begin
+     */
+    dependsOn: Task[];
+    /**
+     * Granular action items that comprise this task
+     */
+    actionItems: ActionItem[];
+    /**
+     * The base branch from which this task's working branch was created
+     */
+    baseBranch: string;
+    /**
+     * Current state of task execution (Todo, WIP, Review, Done)
+     */
+    state: TaskState;
+    /**
+     * Git branch where work for this task is performed
+     */
+    branch: string;
+};
+/**
+ * A significant event in the feature's timeline tracking user interactions and milestones
+ */
+export type TimelineEvent = BaseEntity & {
+    /**
+     * The user query or action that triggered this timeline event
+     */
+    userQuery: string;
+    /**
+     * Timestamp when this event occurred (read-only, set by system)
+     */
+    timestamp: any;
+};
+export declare enum PlanState {
+    Requirements = "Requirements",
+    ClarificationRequired = "ClarificationRequired",
+    Ready = "Ready"
+}
+/**
+ * Individual task representation within a Gantt chart visualization
+ */
+export type GanttTask = {
+    /**
+     * Unique identifier for the Gantt task
+     */
+    id: UUID;
+    /**
+     * Display name of the task shown in the Gantt chart
+     */
+    name: string;
+    /**
+     * Scheduled start time for the task
+     */
+    start: any;
+    /**
+     * Scheduled end time for the task
+     */
+    end: any;
+    /**
+     * IDs of tasks that this task depends on (must complete before this task can start)
+     */
+    dependencies: UUID[];
+    /**
+     * Completion progress as a fraction (0.0 = not started, 1.0 = complete)
+     */
+    progress: number;
+};
+/**
+ * Container for Gantt chart visualization data including tasks and time bounds
+ */
+export type GanttViewData = {
+    /**
+     * Collection of tasks to display in the Gantt chart
+     */
+    tasks: GanttTask[];
+    /**
+     * Start date of the overall work plan (left boundary of the chart)
+     */
+    startDate: any;
+    /**
+     * End date of the overall work plan (right boundary of the chart)
+     */
+    endDate: any;
+};
+/**
+ * Implementation plan for a feature containing tasks, artifacts, and requirements
+ */
+export type Plan = BaseEntity & {
+    /**
+     * High-level overview describing the implementation approach
+     */
+    overview: string;
+    /**
+     * User and inferred requirements that this plan addresses
+     */
+    requirements: Requirement[];
+    /**
+     * Documents and artifacts to be produced as part of this plan
+     */
+    artifacts: Artifact[];
+    /**
+     * Work items (tasks) that comprise this implementation plan
+     */
+    tasks: Task[];
+    /**
+     * Current state of the plan execution lifecycle
+     */
+    state: PlanState;
+    /**
+     * Optional Gantt chart visualization data for work scheduling
+     */
+    workPlan?: GanttViewData;
+};
+export declare enum SdlcLifecycle {
+    Requirements = "Requirements",
+    Research = "Research",
+    Implementation = "Implementation",
+    Review = "Review",
+    DeployAndQA = "Deploy & QA",
+    Maintain = "Maintain"
+}
+/**
+ * Central entity tracking a piece of work through the SDLC lifecycle (Aggregate Root)
+ */
+export type Feature = BaseEntity & {
+    /**
+     * Human-readable name identifying this feature
+     */
+    name: string;
+    /**
+     * URL-friendly identifier derived from name (unique within repository)
+     */
+    slug: string;
+    /**
+     * Detailed description explaining the feature's purpose and scope
+     */
+    description: string;
+    /**
+     * Absolute file system path to the repository
+     */
+    repositoryPath: string;
+    /**
+     * Git branch name where this feature's work is performed
+     */
+    branch: string;
+    /**
+     * Current stage in the SDLC lifecycle
+     */
+    lifecycle: SdlcLifecycle;
+    /**
+     * Conversation history with the AI assistant
+     */
+    messages: Message[];
+    /**
+     * Implementation plan containing tasks, artifacts, and requirements (optional)
+     */
+    plan?: Plan;
+    /**
+     * Generated documents and artifacts attached to this feature
+     */
+    relatedArtifacts: Artifact[];
+};
+export declare enum AgentStatus {
+    Idle = "Idle",
+    Running = "Running",
+    Paused = "Paused",
+    Stopped = "Stopped"
+}
+/**
+ * A running agent instance that processes work and responds to queries
+ */
+export type AgentInstance = {
+    /**
+     * Unique identifier for this agent instance
+     */
+    id: UUID;
+    /**
+     * Git branch this agent is operating on for code changes
+     */
+    branch: string;
+    /**
+     * Current operational status of the agent (Idle, Running, Paused, or Stopped)
+     */
+    status: AgentStatus;
+    /**
+     * Timestamp when this agent instance was created
+     */
+    createdAt: any;
+};
+/**
+ * Deployment target wrapping a single ActionItem for granular deployments
+ */
+export type DeployTargetActionItem = {
+    /**
+     * Discriminator indicating this is an action item target
+     */
+    kind: 'actionItem';
+    /**
+     * The action item to deploy - represents an atomic unit of work
+     */
+    actionItem: ActionItem;
+};
+/**
+ * Deployment target wrapping a single Task for task-level deployments
+ */
+export type DeployTargetTask = {
+    /**
+     * Discriminator indicating this is a task target
+     */
+    kind: 'task';
+    /**
+     * The task to deploy - includes all action items within the task
+     */
+    task: Task;
+};
+/**
+ * Deployment target wrapping multiple Tasks for batch deployments
+ */
+export type DeployTargetTasks = {
+    /**
+     * Discriminator indicating this is a multi-task target
+     */
+    kind: 'tasks';
+    /**
+     * The tasks to deploy - enables batch deployment of related work
+     */
+    tasks: Task[];
+};
+export declare enum FeatureAgentState {
+    GatheringRequirements = "GatheringRequirements",
+    ClarificationsRequired = "ClarificationsRequired",
+    DoingResearch = "DoingResearch",
+    AwaitingReview = "AwaitingReview",
+    ExecutingWorkPlan = "ExecutingWorkPlan",
+    Ready = "Ready"
+}
+/**
+ * Main orchestrating agent - the 'brain' that manages the complete SDLC workflow for a feature
+ */
+export type FeatureAgent = {
+    /**
+     * Unique identifier for this feature agent instance
+     */
+    id: UUID;
+    /**
+     * The feature being managed by this agent throughout its lifecycle
+     */
+    feature: Feature;
+    /**
+     * Sub-agents spawned to handle specific tasks within the workflow
+     */
+    agents: AgentInstance[];
+    /**
+     * Current operational state determining what the agent is doing
+     */
+    state: FeatureAgentState;
+    /**
+     * Timestamp when this feature agent was created
+     */
+    createdAt: any;
+};
+/**
+ * Agent for handling local deployment of features, tasks, or action items
+ */
+export type LocalDeployAgent = {
+    /**
+     * Unique identifier for this deployment agent instance
+     */
+    id: UUID;
+    /**
+     * URL where the deployment is accessible once available (null before deployment)
+     */
+    url?: string;
+    /**
+     * Timestamp when this deployment agent was created
+     */
+    createdAt: any;
+};
+export declare enum PortProtocol {
+    TCP = "TCP",
+    UDP = "UDP"
+}
+/**
+ * Port mapping configuration for exposing container services to the network
+ */
+export type PortMap = {
+    /**
+     * Service name identifier (e.g., 'web', 'api', 'db', 'redis')
+     */
+    name: string;
+    /**
+     * Port number to expose on the host or container network
+     */
+    port: number;
+    /**
+     * Network protocol for the port (defaults to TCP if not specified)
+     */
+    protocol?: PortProtocol;
+};
+export declare enum DeployMethod {
+    DockerCompose = "DockerCompose",
+    Docker = "Docker",
+    Kubernetes = "Kubernetes",
+    Script = "Script",
+    Manual = "Manual"
+}
+/**
+ * Configuration defining how to deploy an application with method and instructions
+ */
+export type DeploySkill = {
+    /**
+     * Unique identifier for the deployment skill configuration
+     */
+    id: UUID;
+    /**
+     * List of port mappings for services to expose when deployed
+     */
+    ports: PortMap[];
+    /**
+     * Method to use for deployment (DockerCompose, Docker, Kubernetes, Script, or Manual)
+     */
+    method: DeployMethod;
+    /**
+     * Deployment instructions or commands to execute for this deployment method
+     */
+    instructions: string;
+    /**
+     * Timestamp when the deployment skill was created
+     */
+    createdAt: any;
+};
+export declare enum DeploymentState {
+    Booting = "Booting",
+    Ready = "Ready",
+    Stopped = "Stopped"
+}
+/**
+ * A running deployment instance with network configuration and lifecycle management
+ */
+export type Deployment = {
+    /**
+     * Unique identifier for the deployment instance
+     */
+    id: UUID;
+    /**
+     * Current state of the deployment (Booting, Ready, or Stopped)
+     */
+    state: DeploymentState;
+    /**
+     * URL where the deployment is accessible (e.g., 'http://localhost:30100/' or 'http://172.33.0.20:5173')
+     */
+    url: string;
+    /**
+     * List of port mappings for services exposed by this deployment
+     */
+    ports: PortMap[];
+    /**
+     * Timestamp when the deployment was created
+     */
+    createdAt: any;
+    /**
+     * Timestamp when the deployment was stopped (only present when state is Stopped)
+     */
+    stoppedAt?: any;
+};
+export type DeployTarget = DeployTargetActionItem | DeployTargetTask | DeployTargetTasks;
+export type Askable = {
+    Ask(request: AskRequest): AskResponse;
+};
+export type FeatureAgentOperations = {
+    NewFeatureWizard(): Feature;
+    GatherRequirements(): Requirement[];
+    DoResearch(): Research;
+    CreatePlan(): Plan;
+    BeginImplementation(): void;
+    Ask(query: string): AskResponse;
+};
+export type LocalDeployAgentOperations = {
+    Deploy(target: DeployTarget, skill: DeploySkill): Deployment;
+    Analyze(repositoryPath: string): DeploySkill;
+    Ask(query: string): AskResponse;
+};
+//# sourceMappingURL=output.d.ts.map