edsger 0.77.0 → 0.78.0

package/dist/commands/session-turn/index.js

@@ -1,254 +0,0 @@
-/**
- * Marker emitted on stdout carrying the SDK session id, so the desktop can
- * persist it on the channel and pass it back via --resume next turn. Kept on
- * its own line and free of logger formatting so it parses cleanly.
- */
-export const SESSION_ID_MARKER = '__EDSGER_SESSION_ID__=';
-/**
- * Marker emitted on stdout for each background `cli_*` run still in flight when
- * the turn ends. The desktop main process parses these, watches each run to
- * completion (the turn process itself exits immediately), and then re-engages
- * the agent via `--run-finished` so it reports results without the user having
- * to ask. The JSON payload is `{ run_id, pid, log_path, command }`.
- */
-export const CLI_RUN_MARKER = '__EDSGER_CLI_RUN__=';
-/**
- * `edsger session-turn <channelId>` — run one conversational agent turn for a
- * chat session (an ai_assistant channel bound to a product).
- *
- * Spawned by the desktop app when the user sends a message in a session. It
- * loads the channel's pending human messages, runs a single Claude Agent SDK
- * turn with the full session toolbelt (createSessionMcpServer — query/action/
- * engineering/cli + conversational + git/PR tools), then posts the reply back
- * to the channel and marks the messages processed. The agent decides what to
- * do (answer, generate stories/test cases, launch cli_* analyses, open PRs);
- * there is no fixed pipeline.
- *
- * The per-turn work is split into {@link prepareSessionContext} (one-time
- * workspace clone + toolbelt + prompt build) and {@link runTurn} (one agent
- * turn against that context). The one-shot `session-turn` command does both
- * once; the long-lived `session-serve` daemon prepares the context once and
- * calls {@link runTurn} repeatedly, keeping the SDK session warm across turns.
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { buildSessionAgentOptions, buildSessionSystemPrompt, buildSessionUserPrompt, createSessionMcpServer, listActiveCliRuns, loadExternalMcpServers, SESSION_MAX_TURNS, } from 'edsger-tools';
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { getToolDeps } from '../../tools/bootstrap.js';
-import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cloneSessionRepos, describeSessionRepos, } from '../../workspace/session-workspace.js';
-/**
- * Clone (or refresh) the session product's repositories into a local session
- * directory and produce the agent's cwd + a prompt note describing the layout.
- *
- * One session dir holds every repo as a subdirectory; clones are reused across
- * turns. Best-effort: if nothing can be cloned (no GitHub config, private repo
- * the token can't reach), the agent still runs — it can answer, file issues,
- * etc. — just without a checked-out codebase.
- */
-async function prepareSessionWorkspace(opts) {
-    let workspace = null;
-    try {
-        workspace = await cloneSessionRepos(opts);
-    }
-    catch (error) {
-        logWarning(`Could not prepare session repos: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return {
-        sessionDir: workspace?.sessionDir,
-        repoScopeNote: workspace ? describeSessionRepos(workspace.repos) : '',
-    };
-}
-/**
- * Build the one-time session context: clone repos, assemble the MCP toolbelt
- * and external servers, and build the system prompt. Cheap to call once per
- * session process; expensive to call per turn (which is why the daemon doesn't).
- */
-export async function prepareSessionContext(options) {
-    const { channelId, productId, repositoryIds = [], resumeSessionId, verbose = false, } = options;
-    // Clone the product's in-scope repositories into a local session directory
-    // so the agent's Read/Grep/Glob can inspect the real code.
-    const { sessionDir, repoScopeNote } = await prepareSessionWorkspace({
-        channelId,
-        productId,
-        repositoryIds,
-        verbose,
-    });
-    const deps = getToolDeps({
-        verbose,
-        context: { productId, channelId, repositoryIds },
-    });
-    const sessionServer = createSessionMcpServer(deps);
-    // User-configured external MCP servers (~/.edsger/mcp.json). Best-effort.
-    const external = loadExternalMcpServers({ warn: logWarning });
-    if (external.names.length > 0) {
-        logInfo(`External MCP servers: ${external.names.join(', ')}`);
-    }
-    const systemPrompt = buildSessionSystemPrompt({
-        channelId,
-        productId,
-        repositoryIds,
-        repoScopeNote,
-        externalMcpNames: external.names,
-    });
-    return {
-        channelId,
-        productId,
-        repositoryIds,
-        verbose,
-        sessionDir,
-        systemPrompt,
-        sessionServer,
-        external,
-        sdkSessionId: resumeSessionId ?? '',
-    };
-}
-/** Emit the SDK session id so the desktop can persist it for the next turn. */
-function emitSessionId(id) {
-    if (id) {
-        process.stdout.write(`\n${SESSION_ID_MARKER}${id}\n`);
-    }
-}
-/**
- * Emit a marker for every background cli_* run still in flight, so the desktop
- * watcher can poll each to completion and re-engage the agent.
- */
-function emitActiveCliRuns() {
-    for (const run of listActiveCliRuns()) {
-        const payload = JSON.stringify({
-            run_id: run.run_id,
-            pid: run.pid,
-            log_path: run.log_path,
-            command: run.command,
-        });
-        process.stdout.write(`\n${CLI_RUN_MARKER}${payload}\n`);
-    }
-}
-/**
- * Run a single agent turn against an already-prepared {@link SessionContext}.
- * Mutates `ctx.sdkSessionId` so the next turn resumes the same SDK conversation
- * (and prompt cache). Safe to call repeatedly for the life of the process.
- */
-export async function runTurn(ctx, opts = {}) {
-    const { runFinished } = opts;
-    // 1. Decide what drives this turn. A normal turn replays the channel's
-    //    pending human messages; a watcher-triggered follow-up replays a
-    //    synthetic prompt about the background run that just finished.
-    let messages = [];
-    if (runFinished) {
-        logInfo(`Reporting completion of background run ${runFinished.runId} for session ${ctx.channelId}`);
-    }
-    else {
-        const pendingResult = (await callMcpEndpoint('chat/messages/pending', {
-            channel_id: ctx.channelId,
-        }));
-        messages = pendingResult.messages ?? [];
-        if (messages.length === 0) {
-            logInfo('No pending messages for this session — nothing to do.');
-            return;
-        }
-        logInfo(`Processing ${messages.length} message(s) for session ${ctx.channelId}`);
-    }
-    const userPrompt = runFinished
-        ? buildRunFinishedPrompt(runFinished)
-        : buildSessionUserPrompt(messages);
-    // 2. Run one SDK turn. Resume the prior SDK session when we have its id so
-    //    the conversation (and prompt cache) carries across turns. Point the
-    //    agent's cwd at the session directory so its read-only file tools resolve
-    //    against the cloned repos. Prompt + tool/MCP wiring come from the shared
-    //    session core (edsger-tools) so CLI and worker can't drift apart.
-    let finalResponse = '';
-    try {
-        for await (const message of query({
-            prompt: userPrompt,
-            options: {
-                ...buildSessionAgentOptions(ctx.systemPrompt, {
-                    sessionServer: ctx.sessionServer,
-                    externalServers: ctx.external.servers,
-                    externalNames: ctx.external.names,
-                    sessionDir: ctx.sessionDir,
-                    maxTurns: SESSION_MAX_TURNS,
-                }),
-                model: DEFAULT_MODEL,
-                ...(ctx.sdkSessionId ? { resume: ctx.sdkSessionId } : {}),
-            },
-        })) {
-            const msg = message;
-            // The system/init and result messages carry the (possibly new) session
-            // id — keep the latest so we persist what the next turn should resume.
-            if (msg.session_id) {
-                ctx.sdkSessionId = msg.session_id;
-            }
-            if (ctx.verbose && msg.type === 'assistant') {
-                logInfo('· agent step');
-            }
-            if (msg.type === 'result') {
-                finalResponse = msg.result || '';
-                break;
-            }
-        }
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        logError(`Session turn failed: ${reason}`);
-        await callMcpEndpoint('chat/messages/send_ai', {
-            channel_id: ctx.channelId,
-            content: `I hit an error processing that: ${reason}`,
-            message_type: 'text',
-            metadata: {},
-        }).catch(() => undefined);
-        emitSessionId(ctx.sdkSessionId);
-        emitActiveCliRuns();
-        await markProcessed(messages);
-        return;
-    }
-    // 3. Post the final reply (the agent may also have posted via
-    //    send_chat_message during the turn; this carries the closing summary).
-    const reply = finalResponse.trim();
-    if (reply) {
-        await callMcpEndpoint('chat/messages/send_ai', {
-            channel_id: ctx.channelId,
-            content: reply,
-            message_type: 'text',
-            metadata: {},
-        }).catch((e) => {
-            logError(`Failed to post reply: ${e instanceof Error ? e.message : String(e)}`);
-        });
-    }
-    // 4. Mark the triggering messages processed so they aren't re-run. (No-op for
-    //    a watcher follow-up, which has no triggering human messages.)
-    await markProcessed(messages);
-    // 5. Emit the SDK session id so the desktop persists it for the next turn,
-    //    plus a marker for any background run launched this turn so the watcher
-    //    keeps following it to completion.
-    emitSessionId(ctx.sdkSessionId);
-    emitActiveCliRuns();
-    logSuccess('Session turn complete.');
-}
-/**
- * One-shot `session-turn`: prepare the context and run a single turn. Retained
- * for callers that want the previous per-turn-process behaviour (and as the
- * building block the daemon reuses).
- */
-export async function runSessionTurnCommand(options) {
-    const ctx = await prepareSessionContext(options);
-    await runTurn(ctx, { runFinished: options.runFinished });
-}
-/**
- * The synthetic user prompt for a watcher-triggered follow-up turn. Steers the
- * agent to inspect what the finished run produced and report it — explicitly
- * NOT to ask the user whether it should check.
- */
-function buildRunFinishedPrompt(runFinished) {
-    const which = runFinished.command
-        ? `the \`${runFinished.command}\` analysis (run ${runFinished.runId})`
-        : `a background analysis you launched earlier (run ${runFinished.runId})`;
-    return `${which} just finished. Inspect what it produced — call get_cli_run with run_id "${runFinished.runId}" for the log tail, then use the list_* / get_* tools (e.g. list_issues) to see the findings it filed. Summarize the results for the user via send_chat_message. Do not ask whether you should check — just report what you found. If nothing of note was produced, say so briefly.`;
-}
-async function markProcessed(messages) {
-    for (const m of messages) {
-        await callMcpEndpoint('chat/messages/mark_processed', {
-            message_id: m.id,
-        }).catch(() => undefined);
-    }
-}

package/dist/commands/smoke-test/index.d.ts

@@ -1,5 +0,0 @@
-export interface SmokeTestCliOptions {
-    releaseId: string;
-    verbose?: boolean;
-}
-export declare const runSmokeTestCommand: (options: SmokeTestCliOptions) => Promise<void>;

package/dist/commands/smoke-test/index.js

@@ -1,40 +0,0 @@
-import { runSmokeTest, } from '../../phases/smoke-test/index.js';
-import { deregisterSession, registerSession, } from '../../system/session-manager.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { validateConfiguration } from '../../utils/validation.js';
-export const runSmokeTestCommand = async (options) => {
-    const { releaseId } = options;
-    if (!releaseId) {
-        throw new Error('Release ID is required for smoke-test');
-    }
-    const config = validateConfiguration({
-        verbose: options.verbose,
-    });
-    await registerSession({ command: 'smoke-test' });
-    logInfo(`Starting smoke-test generation for release: ${releaseId}`);
-    try {
-        const result = await runSmokeTest({
-            releaseId,
-            verbose: options.verbose,
-        }, config);
-        if (result.status === 'success') {
-            logInfo(result.isSnapshot
-                ? `Release: ${result.releaseTag} (snapshot — not yet published on GitHub)`
-                : `Release: ${result.releaseTag}`);
-            logInfo(`Previous: ${result.previousReleaseTag ?? '(none)'}`);
-            logInfo(`Cases generated: ${result.casesCount}`);
-            logInfo('View in the Release detail page of your product dashboard.');
-        }
-        else {
-            logError(`Smoke-test generation failed: ${result.summary}`);
-            process.exitCode = 1;
-        }
-    }
-    catch (error) {
-        logError(`Smoke-test generation failed: ${error instanceof Error ? error.message : String(error)}`);
-        process.exitCode = 1;
-    }
-    finally {
-        await deregisterSession();
-    }
-};

package/dist/commands/state-diagram/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * CLI command: edsger state-diagram <productId> --diagram-id <id>
- * Maps a state machine into the diagrams tables (type='state').
- */
-import { type DiagramCommandOptions } from '../diagram-shared/index.js';
-export type StateDiagramCliOptions = DiagramCommandOptions;
-export declare function runStateDiagram(productId: string | undefined, options: StateDiagramCliOptions): Promise<void>;

package/dist/commands/state-diagram/index.js

@@ -1,9 +0,0 @@
-/**
- * CLI command: edsger state-diagram <productId> --diagram-id <id>
- * Maps a state machine into the diagrams tables (type='state').
- */
-import { runStateDiagramPhase } from '../../phases/state-diagram/index.js';
-import { runDiagramCommand, } from '../diagram-shared/index.js';
-export function runStateDiagram(productId, options) {
-    return runDiagramCommand('state-diagram', productId, options, runStateDiagramPhase);
-}

package/dist/commands/sync-aws/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * CLI command: `edsger sync-aws <teamId>`
- *
- * Uses the standard AWS credential chain (env vars, ~/.aws/credentials,
- * IAM role, etc.) to discover services by their `Service` tag and
- * optionally pull cost data from Cost Explorer.
- *
- * Does NOT store AWS credentials — relies on whatever the user's shell
- * already has configured (same as running `aws` CLI directly).
- */
-export interface SyncAwsOptions {
-    verbose?: boolean;
-    region?: string;
-    noCost?: boolean;
-}
-export declare function runSyncAws(teamId: string, options?: SyncAwsOptions): Promise<void>;

package/dist/commands/sync-aws/index.js

@@ -1,214 +0,0 @@
-/**
- * CLI command: `edsger sync-aws <teamId>`
- *
- * Uses the standard AWS credential chain (env vars, ~/.aws/credentials,
- * IAM role, etc.) to discover services by their `Service` tag and
- * optionally pull cost data from Cost Explorer.
- *
- * Does NOT store AWS credentials — relies on whatever the user's shell
- * already has configured (same as running `aws` CLI directly).
- */
-import { exec as execCb } from 'child_process';
-import { promisify } from 'util';
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-const exec = promisify(execCb);
-async function runAwsCmd(args, region) {
-    const regionFlag = region ? ` --region ${region}` : '';
-    try {
-        const { stdout } = await exec(`aws ${args}${regionFlag} --output json`, {
-            timeout: 30_000,
-        });
-        return stdout;
-    }
-    catch (err) {
-        const e = err;
-        throw new Error(e.stderr?.trim() || e.message);
-    }
-}
-async function checkAwsCli() {
-    try {
-        await exec('aws --version', { timeout: 5000 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function runSyncAws(teamId, options = {}) {
-    const { verbose, noCost } = options;
-    const region = options.region ??
-        process.env.AWS_REGION ??
-        process.env.AWS_DEFAULT_REGION ??
-        'us-east-1';
-    logInfo(`Starting AWS sync for team ${teamId} (region: ${region})`);
-    if (!(await checkAwsCli())) {
-        logError('AWS CLI not found. Install it from https://aws.amazon.com/cli/ ' +
-            'and configure credentials with `aws configure`.');
-        process.exit(1);
-    }
-    // Verify credentials work
-    try {
-        const identity = await runAwsCmd('sts get-caller-identity', region);
-        const parsed = JSON.parse(identity);
-        logInfo(`Authenticated as ${parsed.Arn} (account ${parsed.Account})`);
-    }
-    catch (err) {
-        logError(`AWS credentials not configured or invalid: ${err instanceof Error ? err.message : String(err)}. ` +
-            'Run `aws configure` or export AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY.');
-        process.exit(1);
-    }
-    // ── Phase 1: Resource discovery by Service tag ──
-    logInfo('Phase 1: Discovering resources by Service tag...');
-    const resources = [];
-    try {
-        let paginationToken;
-        do {
-            const tokenArg = paginationToken
-                ? ` --pagination-token "${paginationToken}"`
-                : '';
-            const raw = await runAwsCmd(`resourcegroupstaggingapi get-resources --tag-filters Key=Service${tokenArg}`, region);
-            const parsed = JSON.parse(raw);
-            resources.push(...parsed.ResourceTagMappingList);
-            paginationToken = parsed.PaginationToken || undefined;
-        } while (paginationToken);
-    }
-    catch (err) {
-        logError(`Failed to query tagged resources: ${err instanceof Error ? err.message : String(err)}`);
-        process.exit(1);
-    }
-    logInfo(`Found ${resources.length} tagged resources`);
-    // Group by Service tag value
-    const byService = new Map();
-    for (const res of resources) {
-        const serviceTag = res.Tags.find((t) => t.Key === 'Service')?.Value;
-        if (!serviceTag) {
-            continue;
-        }
-        if (!byService.has(serviceTag)) {
-            byService.set(serviceTag, []);
-        }
-        byService.get(serviceTag).push(res);
-    }
-    logInfo(`Mapped to ${byService.size} distinct services`);
-    let created = 0;
-    let updated = 0;
-    let componentCount = 0;
-    for (const [serviceName, svcResources] of byService) {
-        const teamTag = svcResources[0]?.Tags.find((t) => t.Key === 'Team')?.Value;
-        // Tier signals
-        const hasMultiAz = svcResources.some((r) => r.ResourceARN.includes(':rds:') ||
-            r.ResourceARN.includes(':elasticache:'));
-        const hasLambda = svcResources.some((r) => r.ResourceARN.includes(':lambda:'));
-        const hasEcs = svcResources.some((r) => r.ResourceARN.includes(':ecs:'));
-        const tier = hasMultiAz || (hasEcs && svcResources.length > 3)
-            ? 'critical'
-            : 'standard';
-        const kind = hasLambda && !hasEcs ? 'job' : 'service';
-        if (verbose) {
-            logInfo(`  ${serviceName}: ${svcResources.length} resources, tier=${tier}`);
-        }
-        try {
-            const result = (await callMcpEndpoint('services.upsert_draft', {
-                team_id: teamId,
-                name: serviceName,
-                kind,
-                tier,
-                source: 'aws',
-                source_ref: `aws:${region}:${serviceName}`,
-                field_sources: {
-                    name: {
-                        value: serviceName,
-                        confidence: 1.0,
-                        source: 'aws_tag',
-                        source_detail: 'Tag:Service',
-                    },
-                    tier: {
-                        value: tier,
-                        confidence: hasMultiAz ? 0.8 : 0.5,
-                        source: 'aws_resource_analysis',
-                    },
-                    ...(teamTag
-                        ? {
-                            owner: {
-                                value: teamTag,
-                                confidence: 0.8,
-                                source: 'aws_tag',
-                                source_detail: 'Tag:Team',
-                            },
-                        }
-                        : {}),
-                },
-                needs_review: false,
-            }));
-            if (result.action === 'created') {
-                created++;
-            }
-            else {
-                updated++;
-            }
-            // Add resource components
-            for (const res of svcResources) {
-                const arnParts = res.ResourceARN.split(':');
-                const resourceType = arnParts[2] ?? 'unknown';
-                try {
-                    await callMcpEndpoint('services.add_component', {
-                        service_id: result.service.id,
-                        kind: 'aws_resource',
-                        provider: 'aws',
-                        external_id: res.ResourceARN,
-                        metadata: {
-                            resource_type: resourceType,
-                            region,
-                            tags: Object.fromEntries(res.Tags.map((t) => [t.Key, t.Value])),
-                        },
-                    });
-                    componentCount++;
-                }
-                catch {
-                    // ignore duplicates
-                }
-            }
-        }
-        catch (err) {
-            logWarning(`Failed to sync "${serviceName}": ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    // ── Phase 2: Cost data (optional) ──
-    if (!noCost) {
-        logInfo('Phase 2: Fetching cost data from Cost Explorer...');
-        const now = new Date();
-        const endDate = now.toISOString().slice(0, 10);
-        const startDate = new Date(now.getTime() - 30 * 24 * 3600 * 1000)
-            .toISOString()
-            .slice(0, 10);
-        try {
-            const raw = await runAwsCmd(`ce get-cost-and-usage ` +
-                `--time-period Start=${startDate},End=${endDate} ` +
-                `--granularity MONTHLY ` +
-                `--metrics BlendedCost ` +
-                `--group-by Type=TAG,Key=Service`, region);
-            const parsed = JSON.parse(raw);
-            for (const period of parsed.ResultsByTime) {
-                for (const group of period.Groups) {
-                    const tagValue = group.Keys[0]?.replace('Service$', '') ?? '';
-                    if (!tagValue || tagValue === '') {
-                        continue;
-                    }
-                    const cost = parseFloat(group.Metrics.BlendedCost.Amount);
-                    if (cost <= 0) {
-                        continue;
-                    }
-                    if (verbose) {
-                        logInfo(`  ${tagValue}: $${cost.toFixed(2)}/month`);
-                    }
-                }
-            }
-            logSuccess('Cost data fetched (displayed above, not yet persisted to DB)');
-        }
-        catch (err) {
-            logWarning(`Cost Explorer query failed (may need ce:GetCostAndUsage permission): ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    logSuccess(`AWS sync completed: ${created} created, ${updated} updated, ${componentCount} resource components from ${byService.size} services`);
-}

package/dist/commands/sync-datadog/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * CLI command: `edsger sync-datadog <teamId>`
- *
- * Imports services from a Datadog Service Catalog into the edsger service
- * catalog. Reads DD_API_KEY, DD_APP_KEY, DD_SITE from process.env
- * (populated by `edsger config set` or desktop credentials).
- *
- * Flow:
- *   1. Fetch all service definitions from Datadog API
- *   2. Map each to an edsger service (name, tier, owner, repos, dashboards)
- *   3. Upsert via MCP endpoints (services.upsert_draft, services.add_component)
- */
-export interface SyncDatadogOptions {
-    verbose?: boolean;
-}
-export declare function runSyncDatadog(teamId: string, options?: SyncDatadogOptions): Promise<void>;