@arcforge/axon 0.0.2 → 0.7.3

package/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2025 ArcForge
+
+All rights reserved.
+
+This software and associated documentation files (the "Software") are proprietary
+and confidential to ArcForge.
+
+The Software is licensed, not sold. This license grants you the following rights:
+
+1. You may install and use the Software solely for your internal business purposes.
+
+2. You may not:
+   - Modify, adapt, translate, or create derivative works of the Software
+   - Reverse engineer, decompile, or disassemble the Software
+   - Remove or alter any proprietary notices or labels on the Software
+   - Distribute, sublicense, lease, rent, loan, or transfer the Software to any third party
+   - Use the Software for any purpose other than as expressly permitted herein
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ARCFORGE BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+For licensing inquiries, please contact: legal@arcforge.io

package/README.md

@@ -0,0 +1,195 @@
+# Axon
+
+> **A new generation of agentic intelligence.**
+
+Axon isn't another chatbot with tools. It's a **cognitive operating system** — a distributed network of specialized AI subsystems that coordinate like a real mind to understand, reason, and code alongside you.
+
+```bash
+npm install -g @arcforge/axon
+```
+
+**Built different. Think different.**
+
+---
+
+## What Makes Axon Different?
+
+### Designed Cognition, Not Prompted Behavior
+
+Axon runs on a proprietary **cognitive operating system** that orchestrates dozens of AI models as a single, coherent intelligence. Modular in structure, composable in function, transparent in reasoning.
+
+This isn't prompted behavior. It's **designed cognition**.
+
+### Persistent Memory Architecture
+
+Most agents drown in their own context windows, rereading your project on every turn. Axon forms a **persistent semantic map** of your codebase — architecture, patterns, conventions, dependencies — and recalls only what's relevant in the moment.
+
+- **No tokens wasted** on redundant context
+- **No scanning or searching** — it simply remembers
+- **Evolving understanding** that improves as you work together
+
+### Network Intelligence
+
+A distributed network of specialized subsystems coordinate seamlessly:
+- **Planners** design implementation strategies
+- **Coders** write clean, contextual solutions
+- **Critics** review for quality and correctness
+- **Test Writers** ensure robustness
+
+All working together as a single, cohesive intelligence runtime.
+
+### No Slop, Just Code
+
+Axon understands your architecture, follows your patterns, and writes thoughtful solutions. No unnecessary abstractions, no premature optimizations, no junior-level mistakes.
+
+It thinks like a senior engineer because it's **designed to think**, not just pattern-match.
+
+---
+
+## Quick Start
+
+```bash
+# Install globally
+npm install -g @arcforge/axon
+
+# Launch the terminal UI
+axon
+```
+
+**Requirements:**
+- [Bun](https://bun.sh) runtime installed
+- Valid Axon API key (get yours at [axon.hexlabs.co.uk](https://axon.hexlabs.co.uk))
+
+---
+
+## Features
+
+### Beautiful Terminal UI
+Built with Blessed for a responsive, full-featured text user interface. Navigate with keyboard shortcuts, manage multiple workspaces, and visualize agent reasoning in real-time.
+
+### Network Intelligence
+Multiple specialized AI subsystems coordinating as a single mind — planners, critics, coders, test writers — all working in parallel across intelligent inference pipelines.
+
+### Process Management
+Monitor and control running processes, track execution state, and visualize the cognitive control loop in action.
+
+### Kanban-Style Task Management
+Built-in task board for organizing work, tracking agent decisions, and managing multi-step implementations.
+
+### Device Authentication
+Secure device flow authentication connects your CLI to your Axon account seamlessly.
+
+### Real-Time Visualizations
+Audio visualizer, system metrics, and cognitive state monitoring — see your agent think.
+
+---
+
+## Usage
+
+Once launched, navigate with:
+
+- **Arrow keys** → Navigate menus and panels
+- **Enter** → Select / Execute
+- **Esc** → Go back
+- **Tab** → Switch between panels
+- **/help** → View all commands
+
+### Example Session
+
+```bash
+$ axon
+
+# Initialize context for your project
+> axon init
+
+# Ask questions about your codebase
+> "Why was this module created?"
+> "What depends on this function?"
+
+# Request implementations
+> "Add user authentication with JWT"
+
+# The agent plans, codes, tests, and explains its reasoning
+```
+
+---
+
+## How It Works
+
+### 1. **Initialize** — Build a Semantic Map
+
+As Axon explores your codebase, it forms a persistent map of how everything fits together. Not files. Not tokens. But **meaning**: purpose, relationships, design intent.
+
+### 2. **Instruct** — Context Without Friction
+
+Ask questions like a senior engineer would:
+- "Why was this module created?"
+- "What depends on this function?"
+- "How did this system evolve over time?"
+
+Axon answers immediately — without scanning, searching, or invoking tools. It simply **remembers**.
+
+### 3. **Execute** — Distributed Intelligence
+
+Complex tasks are routed across parallel inference pipelines. Heavy reasoning goes deep with advanced models. Simple tasks stay lean and fast.
+
+A purpose-built cognitive architecture that makes traditional LLM tools feel like they're standing still.
+
+---
+
+## Architecture
+
+Axon is powered by:
+
+- **Cognitive Operating System** — Proprietary runtime for orchestrating distributed AI subsystems
+- **Persistent Memory Layer** — Semantic graph storage with contextual retrieval
+- **Parallel Inference Pipelines** — Intelligent task routing across model tiers
+- **Real-Time State Monitoring** — Observable cognitive control loop
+
+Built on [Cognos](https://cognos.dev) — a first-class cognitive framework for agentic intelligence.
+
+---
+
+## Authentication
+
+Axon uses **device flow authentication** to securely connect your CLI to your account:
+
+1. Run `axon` for the first time
+2. Visit the authentication URL shown in the terminal
+3. Approve the device from your browser
+4. Start coding
+
+Your API key is stored securely and refreshed automatically.
+
+---
+
+## Credits & Billing
+
+Axon operates on a **credit-based system**:
+
+- **1,000 credits per £1**
+- **Subscription plans** grant monthly credit allocations
+- **Top-ups** available for one-time purchases
+- Credits never expire
+
+Manage your subscription at [axon.hexlabs.co.uk/billing](https://axon.hexlabs.co.uk/billing)
+
+---
+
+## Support
+
+- **Website**: [axon.hexlabs.co.uk](https://axon.hexlabs.co.uk)
+- **Documentation**: [axon.hexlabs.co.uk/docs](https://axon.hexlabs.co.uk/docs)
+- **Billing**: [axon.hexlabs.co.uk/billing](https://axon.hexlabs.co.uk/billing)
+
+---
+
+## License
+
+Copyright © 2025 ArcForge. All rights reserved.
+
+This is proprietary software. See [LICENSE](./LICENSE) for details.
+
+---
+
+**Built different. Think different.**

package/app/index.ts

@@ -0,0 +1,204 @@
+import blessed from "blessed"
+
+import {
+    useAudioVisualizer,
+    useScreen,
+    useCommands,
+    useCognos,
+    useStack,
+    useRouter,
+    useDeviceAuth,
+} from "#composables"
+
+import {
+    ChatPage,
+    KanbanPage,
+    LoginPage,
+    ProcessesPage,
+    ProcessDetailPage,
+    ProfilePage,
+    ThemePage,
+} from "#pages"
+import { builtinCommands, processCommands, kanbanCommands, parseArgs, printHelp, executePrompt, redirectConsoleToFile, restoreConsole, getLogFilePath } from "#lib"
+import { Footer } from "#components"
+
+
+/**
+ * Interactive mode: Full blessed TUI
+ *
+ * The screen consists of two regions:
+ *
+ * - The current page (chat, login, etc.), containing page-specific content.
+ * - The footer, containing chat input and menus.
+ *
+ */
+async function mainInteractive(debug: boolean = false) {
+    // Redirect console output to prevent TUI corruption (unless debug mode)
+    if (!debug) {
+        redirectConsoleToFile()
+    }
+
+    const screen = useScreen()
+    const commands = useCommands()
+    const stackComposable = useStack()
+    const cognos = useCognos()
+    const router = useRouter()
+    const deviceAuth = useDeviceAuth()
+
+    // Register builtin commands
+    builtinCommands.forEach(cmd => commands.register(cmd))
+
+    // Register process management commands
+    processCommands.forEach(cmd => commands.register(cmd))
+
+    // Register kanban commands
+    kanbanCommands.forEach(cmd => commands.register(cmd))
+
+
+    // Navigate to chat immediately if at root
+    if (router.current().path === "/") {
+        router.navigate("/chat")
+    }
+
+    // Start auth check in background (non-blocking)
+    // The result will be awaited later when the user sends their first message
+    deviceAuth.checkAuth().then(isAuthenticated => {
+        if (isAuthenticated) {
+            // Only connect to websocket after successful auth
+            cognos.connect().catch(error => {
+                console.error("Failed to connect to websocket:", error)
+            })
+        } else if (router.current().path !== "/login") {
+            // Redirect to login if auth fails
+            router.navigate("/login")
+        }
+    })
+
+    const container = blessed.box({
+        width: "100%",
+        height: "100%",
+        layout: "vertical",
+    })
+
+    const footer = Footer()
+
+    // Create page mapping with route patterns
+    const routes = [
+        { pattern: "/login", component: () => LoginPage() },
+        { pattern: "/chat", component: () => ChatPage() },
+        { pattern: "/kanban", component: () => KanbanPage() },
+        { pattern: "/processes", component: () => ProcessesPage() },
+        { pattern: "/processes/:refId", component: () => ProcessDetailPage() },
+        { pattern: "/profile", component: () => ProfilePage() },
+        { pattern: "/theme", component: () => ThemePage() },
+    ]
+
+    // Helper to find matching route
+    function findMatchingRoute(path: string) {
+        for (const route of routes) {
+            const match = router.match(route.pattern)
+            if (match) {
+                return route
+            }
+        }
+        // Default to login if no match
+        return routes[0]
+    }
+
+    // Initialize with the current page
+    const initialRoute = findMatchingRoute(router.current().path)
+    let currentPageNode = initialRoute.component().node
+
+    container.append(footer.node)
+    container.append(currentPageNode)
+
+    screen.append(container)
+    screen.append(footer.paletteNode) // Append command palette to screen so it floats above footer
+    screen.append(footer.pagePaletteNode) // Append page palette to screen so it floats above footer
+    screen.render()
+
+    // Focus the input initially
+    footer.focus()
+
+    // Handle page navigation
+    router.onNavigate((route) => {
+        // Remove current page
+        container.remove(currentPageNode)
+
+        // Find matching route and create page
+        const matchedRoute = findMatchingRoute(route.path)
+        currentPageNode = matchedRoute.component().node
+        container.append(currentPageNode)
+
+        // Keep footer on top
+        container.remove(footer.node)
+        container.append(footer.node)
+
+        screen.render()
+    })
+
+    // Initialize audio visualizer (will activate in voice mode)
+    const audioVisualizer = useAudioVisualizer()
+    audioVisualizer.init()
+
+    // Show Axon logo and stats on boot
+    const axonCmd = builtinCommands.find(cmd => cmd.name === "axon")
+    if (axonCmd) {
+        axonCmd.execute()
+    }
+
+    stackComposable.onUpdate(() => {
+        // Put the footer back at the top (z-index).
+        container.remove(footer.node)
+        container.append(footer.node)
+        screen.render()
+    })
+
+    // Setup cleanup handlers for websocket and capsule
+    const cleanup = async () => {
+        cognos.disconnect()
+        if (!debug) {
+            restoreConsole()
+        }
+    }
+
+    process.on("SIGINT", async () => {
+        await cleanup()
+        process.exit(0)
+    })
+
+    process.on("exit", async () => {
+        await cleanup()
+    })
+
+    screen.key(["C-c"], async () => {
+        await cleanup()
+        process.exit(0)
+    })
+}
+
+/**
+ * Main entry point: Parse args and route to appropriate mode
+ */
+async function main() {
+    const args = parseArgs(process.argv.slice(2))
+
+    if (args.help) {
+        printHelp()
+        process.exit(0)
+    }
+
+    if (args.mode === 'prompt') {
+        if (!args.prompt) {
+            console.error("Error: --prompt requires a value")
+            process.exit(1)
+        }
+        await executePrompt(args.prompt)
+        process.exit(0)
+    }
+
+    // Interactive mode (default)
+    await mainInteractive(args.debug || false)
+}
+
+await main()