@agilemonster/mcp-server 1.0.16 → 1.0.21

package/dist/deploy-memory.js

@@ -0,0 +1,192 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { agileMonsterHome, readJson, writeJsonAtomic } from './runtime.js';
+const HISTORY_LIMIT = 30;
+const CARD_STATE_LIMIT = 200;
+const DEPLOYED_CARDS_LIMIT = 300;
+const STALE_CARD_STATE_MS = 45 * 24 * 60 * 60 * 1000;
+export function memoryFileFor(projectPath) {
+    const resolved = path.resolve(projectPath);
+    const hash = crypto.createHash('sha1').update(resolved).digest('hex').slice(0, 10);
+    const slug = path.basename(resolved).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'project';
+    return path.join(agileMonsterHome(), 'projects', `${slug}-${hash}.json`);
+}
+/**
+ * Recover "how the last deployment worked" from the activity log earlier daemon versions wrote into the
+ * project (`.agilemonster/ACTIVITY.md`), so projects that already deployed successfully keep their route
+ * instead of starting from a fresh guess.
+ */
+export function parseLastDeploymentFromActivityLog(logText) {
+    // The log mixes daemon output with card titles and model-written summaries, so it is only trusted for
+    // WHICH of the two routine routes last succeeded — never for a command to run. (A script route found
+    // this way would still have to be confirmed by a human.) Headings carry card titles: skip them.
+    const lines = logText
+        .split(/\r?\n/)
+        .filter((l) => l.includes('🚀 **Deployed**') && !l.trimStart().startsWith('#'));
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i].slice(lines[i].indexOf('🚀 **Deployed**'));
+        if (/deployed (?:via|with) `/i.test(line))
+            return null; // last route was a script/CLI: needs confirmation, not seeding
+        if (/Docker (containers rebuilt|Compose)/i.test(line))
+            return { method: 'docker_compose', command: null };
+        if (/GitHub Actions (deployment )?passed/i.test(line))
+            return { method: 'github_actions', command: null };
+    }
+    return null;
+}
+function seedFromActivityLog(projectPath) {
+    try {
+        const file = path.join(projectPath, '.agilemonster', 'ACTIVITY.md');
+        if (!fs.existsSync(file))
+            return null;
+        const stat = fs.statSync(file);
+        const fd = fs.openSync(file, 'r');
+        const length = Math.min(stat.size, 300 * 1024);
+        const buffer = Buffer.alloc(length);
+        fs.readSync(fd, buffer, 0, length, stat.size - length);
+        fs.closeSync(fd);
+        const found = parseLastDeploymentFromActivityLog(buffer.toString('utf8'));
+        if (!found)
+            return null;
+        return { method: found.method, command: found.command, at: stat.mtime.toISOString(), commit: null, card_id: null };
+    }
+    catch {
+        return null;
+    }
+}
+export function loadMemory(projectPath) {
+    const file = memoryFileFor(projectPath);
+    const stored = readJson(file);
+    if (!stored && !fs.existsSync(file)) {
+        const seeded = seedFromActivityLog(projectPath);
+        if (seeded) {
+            const memory = {
+                project_path: path.resolve(projectPath),
+                updated_at: new Date().toISOString(),
+                explicit: null,
+                last_success: seeded,
+                failures: {},
+                history: [],
+                pending: [],
+                cards: {},
+                deployed_cards: {},
+            };
+            saveMemory(memory);
+            return memory;
+        }
+    }
+    return {
+        project_path: path.resolve(projectPath),
+        updated_at: stored?.updated_at || new Date(0).toISOString(),
+        explicit: stored?.explicit || null,
+        last_success: stored?.last_success || null,
+        failures: stored?.failures && typeof stored.failures === 'object' ? stored.failures : {},
+        history: Array.isArray(stored?.history) ? stored.history : [],
+        pending: Array.isArray(stored?.pending) ? stored.pending : [],
+        cards: stored?.cards && typeof stored.cards === 'object' ? stored.cards : {},
+        deployed_cards: stored?.deployed_cards && typeof stored.deployed_cards === 'object' ? stored.deployed_cards : {},
+    };
+}
+export function saveMemory(memory) {
+    memory.updated_at = new Date().toISOString();
+    // Card state means "edits exist that still have to ship": only drop it when it is clearly abandoned.
+    const cardIds = Object.keys(memory.cards);
+    for (const id of cardIds) {
+        if (Date.now() - (Date.parse(memory.cards[id].at) || 0) > STALE_CARD_STATE_MS)
+            delete memory.cards[id];
+    }
+    const remaining = Object.keys(memory.cards);
+    if (remaining.length > CARD_STATE_LIMIT) {
+        remaining
+            .sort((a, b) => (memory.cards[a].at < memory.cards[b].at ? -1 : 1))
+            .slice(0, remaining.length - CARD_STATE_LIMIT)
+            .forEach((id) => delete memory.cards[id]);
+    }
+    const deployedIds = Object.keys(memory.deployed_cards);
+    if (deployedIds.length > DEPLOYED_CARDS_LIMIT) {
+        deployedIds
+            .sort((a, b) => (memory.deployed_cards[a].at < memory.deployed_cards[b].at ? -1 : 1))
+            .slice(0, deployedIds.length - DEPLOYED_CARDS_LIMIT)
+            .forEach((id) => delete memory.deployed_cards[id]);
+    }
+    memory.history = memory.history.slice(-HISTORY_LIMIT);
+    try {
+        writeJsonAtomic(memoryFileFor(memory.project_path), memory);
+    }
+    catch {
+        // Memory is an optimization; failing to persist it must never fail a deployment.
+    }
+}
+/** Record the outcome of an attempt and update what the project "knows" about its own deployment. */
+export function recordAttempt(projectPath, attempt) {
+    const memory = loadMemory(projectPath);
+    const at = new Date().toISOString();
+    const { live_url: liveUrl, wrong_method: wrongMethod, unverified, ...rest } = attempt;
+    memory.history.push({ at, ...rest, error: rest.error ? rest.error.slice(0, 600) : rest.error });
+    if (attempt.ok && attempt.card_id) {
+        memory.deployed_cards[attempt.card_id] = {
+            at,
+            commit: attempt.commit || null,
+            method: attempt.method,
+            verified: !attempt.pending && !unverified,
+        };
+    }
+    // Only a deployment that was actually verified teaches the project its route
+    if (attempt.ok && !attempt.pending && !unverified) {
+        memory.last_success = {
+            method: attempt.method,
+            command: attempt.command || null,
+            live_url: liveUrl || memory.last_success?.live_url || null,
+            at,
+            commit: attempt.commit || null,
+            card_id: attempt.card_id || null,
+        };
+        delete memory.failures[attempt.method];
+    }
+    else if (!attempt.ok) {
+        const prev = memory.failures[attempt.method];
+        memory.failures[attempt.method] = {
+            count: (prev?.count || 0) + 1,
+            last_kind: attempt.kind || null,
+            last_error: attempt.error ? attempt.error.slice(0, 400) : null,
+            last_at: at,
+            wrong_method: Boolean(wrongMethod),
+        };
+    }
+    saveMemory(memory);
+    return memory;
+}
+export function setExplicitProfile(projectPath, explicit) {
+    const memory = loadMemory(projectPath);
+    memory.explicit = { ...explicit, set_at: new Date().toISOString() };
+    // A human or IDE agent just told us how to deploy: earlier failures of that method are no longer a reason to avoid it.
+    delete memory.failures[explicit.method];
+    saveMemory(memory);
+    return memory;
+}
+export function setCardState(projectPath, cardId, state) {
+    const memory = loadMemory(projectPath);
+    if (state)
+        memory.cards[cardId] = state;
+    else
+        delete memory.cards[cardId];
+    saveMemory(memory);
+}
+export function getCardState(projectPath, cardId) {
+    return loadMemory(projectPath).cards[cardId] || null;
+}
+export function addPendingVerification(projectPath, pending) {
+    const memory = loadMemory(projectPath);
+    memory.pending = memory.pending.filter((p) => p.card_id !== pending.card_id);
+    memory.pending.push(pending);
+    saveMemory(memory);
+}
+export function removePendingVerification(projectPath, cardId) {
+    const memory = loadMemory(projectPath);
+    const next = memory.pending.filter((p) => p.card_id !== cardId);
+    if (next.length !== memory.pending.length) {
+        memory.pending = next;
+        saveMemory(memory);
+    }
+}

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;