What Programming Languages Are Used in kenn-io/agentsview?

The kenn-io/agentsview repository uses Go for the backend server, TypeScript with Svelte for the frontend application, and Bash, PowerShell, and Python for automation scripts.

The agentsview project implements a polyglot architecture that pairs a high-performance Go backend with a modern TypeScript frontend to create a full-stack AI session viewer. This mixed-language approach optimizes for execution speed on the server while maintaining type-safe, reactive client-side code.

Backend Implementation in Go

Go powers the core application logic, HTTP server, database layer, and file synchronization engine. The backend handles SQLite and PostgreSQL access, configuration management, and real-time updates through Server-Sent Events (SSE).

Entry Point and Server Initialization

The application boots from cmd/agentsview/main.go, which initializes the HTTP server using the server.Start() function:

// cmd/agentsview/main.go
package main

import (
    "context"
    "log"
    "github.com/kenn-io/agentsview/internal/server"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    // Initialise and run the HTTP server (port defaults to 8080)
    if err := server.Start(ctx); err != nil {
        log.Fatalf("server failed: %v", err)
    }
}

Core Server and Parser Logic

The internal/server/server.go file defines routing, middleware, and SSE endpoints, while internal/parser/types.go registers supported AI agents and their parsers. Go also manages the embedding of frontend assets through internal/web/embed.go, which bundles the compiled TypeScript/Svelte application into the final binary.

Frontend Stack: TypeScript and Svelte

The frontend is implemented as a Single Page Application (SPA) using TypeScript with the Svelte framework, compiled and bundled by Vite. This combination provides type safety and reactive UI components for viewing AI agent sessions.

Client-Side Utilities

The frontend/src/lib/utils/agents.ts file contains type definitions and data fetching logic for agent metadata:

// frontend/src/lib/utils/agents.ts
import { writable } from 'svelte/store';

export interface Agent {
  id: string;
  name: string;
  description: string;
}

export const agents = writable<Agent[]>([]);

/** Fetch the list of agents from the backend API */
export async function loadAgents() {
  const resp = await fetch('/api/agents');
  const data: Agent[] = await resp.json();
  agents.set(data);
}

Bootstrap and Build Integration

The application entry point at frontend/src/main.ts mounts the root Svelte component. During the build process, these TypeScript sources compile into JavaScript and are embedded into the Go binary, allowing the server to serve static assets without external dependencies.

Automation and Utility Scripts

Shell Scripting with Bash

Bash scripts orchestrate build tasks, testing, and CI/CD pipelines. The scripts/e2e-server.sh script demonstrates how the repository automates end-to-end testing by building the Go binary and running Playwright tests:

# scripts/e2e-server.sh

#!/usr/bin/env bash
set -euo pipefail

# Build the binary

make build

# Start the server in the background

./agentsview & SERVER_PID=$!

# Run Playwright tests against the running server

npm run e2e

# Clean up

kill $SERVER_PID

Additional scripts like scripts/check-docs.sh verify documentation consistency during continuous integration.

Cross-Platform Support with PowerShell

For Windows environments, scripts/install.ps1 provides PowerShell-based installation helpers, ensuring the project builds correctly across different operating systems without requiring Unix-specific tooling.

Python Utilities

The repository includes Python scripts for specialized build tasks. The scripts/build_wheels.py utility generates platform-specific wheel distributions for CI pipelines, handling Python package building that complements the primary Go and TypeScript codebases.

Infrastructure and Build Orchestration

Containerization

The Dockerfile defines a multi-stage build process that compiles the Go binary and embeds the frontend assets, creating a self-contained container image that requires no external volume mounts for static files.

Makefile Build System

The Makefile provides the primary build interface, coordinating Go compilation, frontend bundling, and test execution through standard targets like make build, make dev, and make test.

Summary

• Go handles the backend server, database connections, file sync, and HTTP API in cmd/agentsview/main.go and internal/server/server.go
• TypeScript with Svelte powers the frontend SPA, with entry points in frontend/src/main.ts and utilities in frontend/src/lib/utils/agents.ts
• Bash scripts automate testing and CI/CD workflows in files like scripts/e2e-server.sh
• PowerShell provides Windows-specific automation via scripts/install.ps1
• Python supports build processes through scripts/build_wheels.py
• Dockerfile and Makefile define containerization and build orchestration using their respective domain-specific languages

Frequently Asked Questions

Is kenn-io/agentsview primarily a Go project?

While Go serves as the primary backend language handling HTTP requests, database access, and business logic, the repository is fundamentally a mixed-language project. The frontend constitutes a significant TypeScript/Svelte codebase that compiles into the Go binary, making it a full-stack rather than pure Go application.

How does the frontend integrate with the Go backend?

The TypeScript frontend is compiled into static assets and embedded directly into the Go binary using internal/web/embed.go. This architecture allows the Go server to serve the SPA and API endpoints from a single process without requiring separate static file servers or reverse proxies in production.

Why does agentsview use multiple scripting languages?

The project uses Bash for Unix-based CI/CD automation, PowerShell for Windows compatibility, and Python for specific build utilities like wheel generation. This polyglot scripting approach ensures cross-platform support while leveraging the most appropriate tool for each automation task, rather than forcing a single scripting language for all platforms.

Can I run agentsview without knowing all these languages?

Yes. End users only need to interact with the compiled binary or Docker image. Developers contributing to the core application should understand Go for backend changes and TypeScript for frontend modifications, while the scripting languages are primarily maintained for build and release automation.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}