@agilemonster/mcp-server 1.0.15 → 1.0.21

package/dist/deploy-profile.d.ts

@@ -0,0 +1,151 @@
+import type { ProjectMemory } from './deploy-memory.js';
+/**
+ * Evidence-based deployment profile resolution.
+ *
+ * The old detector returned the first deploy-looking file it found (any compose file won), and the
+ * server kept that first guess forever. This module instead gathers every piece of evidence a project
+ * offers — how the running containers were actually started, which CI workflows really fire on a push
+ * to the current branch, deploy scripts, cloud CLI configs, the project's own docs, and what worked
+ * last time — ranks the candidates, and says how confident it is and why.
+ *
+ * Precedence: explicit project file > user-set binding > last verified success > ranked evidence.
+ */
+export type DeployMethod = 'github_actions' | 'docker_compose' | 'deploy_script' | 'cloud_cli' | 'git_push' | 'manual' | 'none';
+export type ProfileSource = 'explicit' | 'user' | 'learned' | 'verified' | 'detected';
+export type Confidence = 'high' | 'medium' | 'low';
+export interface PushTrigger {
+    branches: string[] | null;
+    branchesIgnore: string[] | null;
+    paths: string[] | null;
+    pathsIgnore: string[] | null;
+    tagsOnly: boolean;
+}
+export interface WorkflowInfo {
+    file: string;
+    name: string;
+    isDeploy: boolean;
+    events: string[];
+    push: PushTrigger | null;
+    dispatch: boolean;
+    workflowRun: {
+        workflows: string[];
+        branches: string[] | null;
+    } | null;
+}
+export interface ComposeFileInfo {
+    rel: string;
+    kind: 'default' | 'dev' | 'prod' | 'other';
+    hasBuild: boolean;
+}
+export interface ComposeStack {
+    projectName: string;
+    workingDir: string;
+    configFiles: string[];
+    services: string[];
+    runningCount: number;
+}
+export interface ComposeTarget {
+    projectName: string | null;
+    /** Compose files relative to the project root (or absolute when outside it). */
+    files: string[];
+    running: boolean;
+}
+export interface DeployCandidate {
+    method: DeployMethod;
+    command: string | null;
+    score: number;
+    evidence: string[];
+    compose?: ComposeTarget;
+    /** Deploy workflows that this candidate relies on. */
+    workflows?: WorkflowInfo[];
+    /** The deploy workflow only starts when dispatched (pushing alone does not deploy). */
+    dispatchOnly?: boolean;
+}
+export interface BoundProfile {
+    deploy_method?: string | null;
+    deploy_command?: string | null;
+    live_url?: string | null;
+    build_command?: string | null;
+    /** 'user' = set by a human, 'verified' = confirmed by a successful deploy, 'auto' = a guess. */
+    deploy_source?: string | null;
+}
+export interface GitInfo {
+    isRepo: boolean;
+    branch: string | null;
+    hasRemote: boolean;
+    remoteUrl: string | null;
+}
+export interface DeployProfile {
+    method: DeployMethod;
+    command: string | null;
+    source: ProfileSource;
+    confidence: Confidence;
+    evidence: string[];
+    liveUrl: string | null;
+    /** 'guessed' URLs are informational: an unreachable guess must never fail a deployment. */
+    liveUrlSource: 'explicit' | 'user' | 'learned' | 'guessed' | null;
+    buildCommand: string | null;
+    compose?: ComposeTarget;
+    workflows: WorkflowInfo[];
+    dispatchOnly: boolean;
+    /**
+     * The route was only inferred and would run something with production reach that nobody has confirmed
+     * (a deploy script, a cloud CLI, a manually-dispatched workflow). Ask once, then remember.
+     */
+    needsConfirmation: boolean;
+    alternatives: DeployCandidate[];
+    git: GitInfo;
+    deploymentNotes: string;
+}
+export interface ProfileProbes {
+    /** Output of the docker ps probe (see COMPOSE_PS_FORMAT), or null when docker is unavailable. */
+    dockerPs?: () => string | null;
+    git?: (projectPath: string) => GitInfo;
+}
+export interface ResolveOptions {
+    bound?: BoundProfile | null;
+    memory?: ProjectMemory | null;
+    probes?: ProfileProbes;
+}
+export declare function normalizeMethod(raw: string | null | undefined): DeployMethod | null;
+/**
+ * Older versions stored descriptions such as "git push origin HEAD (GitHub Actions CI/CD)" in the command
+ * field. Those are not commands. (Real commands may contain parentheses, e.g. `TAG=$(git rev-parse HEAD)`.)
+ */
+export declare function isRunnableCommand(cmd: string | null | undefined): boolean;
+export declare function globToRegExp(glob: string): RegExp;
+export declare function parseWorkflow(file: string, text: string): WorkflowInfo;
+export declare function readWorkflows(projectPath: string): WorkflowInfo[];
+/** Does a push to `branch` start this workflow, directly or through a `workflow_run` chain? */
+export declare function workflowRunsOnPush(wf: WorkflowInfo, branch: string, all: WorkflowInfo[], depth?: number): boolean;
+/** With `paths:` filters, a commit that touches none of them does not start the workflow. */
+export declare function pushPathsMatch(push: PushTrigger | null, files: string[]): boolean;
+export declare const COMPOSE_PS_FORMAT = "{{.Label \"com.docker.compose.project\"}}\t{{.Label \"com.docker.compose.project.working_dir\"}}\t{{.Label \"com.docker.compose.project.config_files\"}}\t{{.Label \"com.docker.compose.service\"}}\t{{.State}}";
+export declare function findComposeFiles(projectPath: string): ComposeFileInfo[];
+/** Parse the docker ps probe and keep the compose projects that were started from inside `projectPath`. */
+export declare function parseComposeStacks(psOutput: string, projectPath: string): ComposeStack[];
+export declare function composeCommand(target: ComposeTarget, tail?: string): string;
+/** Arguments for `docker compose …` matching a target (no shell quoting needed). */
+export declare function composeArgs(target: ComposeTarget): string[];
+/** Pull the lines of the project docs that talk about deployment (compact, for the code model and for humans). */
+export declare function extractDeploymentNotes(projectPath: string, maxChars?: number): string;
+export declare function detectBuildCommand(projectPath: string): string | null;
+/** "app.example.co.za" -> "example": the label a project name can be compared with. */
+export declare function registrableLabel(host: string): string;
+/**
+ * Best-effort production URL. Returns a URL only when something ties it to this project
+ * (an APP_URL-style env value, a doc URL whose host resembles the project/repo name, or a
+ * folder literally named like a domain) — never just "the first link in the README".
+ */
+export declare function inferLiveUrl(projectPath: string, name: string, remoteUrl?: string | null): string | null;
+export declare function gatherCandidates(projectPath: string, git: GitInfo, workflows: WorkflowInfo[], dockerPs: string | null): DeployCandidate[];
+export declare function resolveDeployProfile(projectPath: string, options?: ResolveOptions): DeployProfile;
+/**
+ * Pushing to the checked-out branch (and whatever pipeline the repo attached to that) and refreshing local
+ * containers are routine. Running a deploy script, a cloud CLI, or manually dispatching a workflow reaches
+ * production in ways the repository did not automate — so an unconfirmed guess must be confirmed once.
+ */
+export declare function requiresConfirmation(candidate: Pick<DeployCandidate, 'method' | 'dispatchOnly'>): boolean;
+export declare function methodLabel(method: DeployMethod): string;
+/** Compact, human-readable description used in card comments, the code model's context, and MCP tool output. */
+export declare function describeProfile(profile: DeployProfile): string;