astrabot 0.1.0

package/modes/agent/types.ts

@@ -0,0 +1,68 @@
+export type ActionType = 
+    | 'file_create'
+    | 'file_modify'
+    | 'file_delete'
+    | 'folder_create'
+    | 'code_analysis'
+    | 'tool_execute'
+
+export type ActionStatus = 'pending' | 'executed' | 'approved' | 'rejected'
+
+export interface ActionLog {
+    id: string;
+    timestamp: Date;
+    type: ActionType;
+    path: string;
+    details: {
+        before?: string;
+        after?: string;
+        toolName?: string;
+        toolResult?: string;
+        error?: string;
+        command?: string;
+    };
+    status: ActionStatus;
+    userApproved?: boolean;
+}
+
+export interface AgentConfig {
+    codebasePath: string;
+    maxFileSizeToRead: number;
+    excludePatterns: string[];
+    tools: {
+        allowShellExecution: boolean;
+        allowFileModification: boolean;
+        allowFileCreation: boolean;
+        allowFolderCreation: boolean;
+    }
+}
+
+export const defaultAgentConfig = (): AgentConfig => ({
+    codebasePath: process.cwd(),
+    maxFileSizeToRead: 1024*1024,
+    excludePatterns: [
+        'node_modules',
+        '.git',
+        'dist',
+        'build',
+        '.next',
+        '*.log',
+        '.env*'
+    ],
+    tools: {
+        allowShellExecution: true,
+        allowFileModification: true,
+        allowFileCreation: true,
+        allowFolderCreation: true,
+    }
+})
+
+export function isMutationType(t: ActionType): boolean {
+    return (
+        t==='file_create' ||
+        t==='file_modify' ||
+        t==='file_delete' ||
+        t==='folder_create' ||
+        t==='tool_execute' 
+    )
+}

package/modes/ask/orchestrator.ts

@@ -0,0 +1,230 @@
+import z from "zod";
+import chalk from "chalk";
+import { confirm, isCancel, text } from "@clack/prompts";
+import { ToolLoopAgent, stepCountIs } from "ai";
+import { getAgentModel } from "../../ai/ai.config";
+import { ActionTracker } from "../agent/action-tracker";
+import { ToolExecutor } from "../agent/tool-executor";
+import { createAgentTools } from "../agent/agent-tools";
+import { defaultAgentConfig } from "../agent/types";
+import { runApprovalFlow } from "../agent/approval";
+import { renderTerminalMarkdown } from "../../tui/terminal-md";
+import { createWebTools } from "../plan/web-tools";
+import { withSpinner } from "../../tui/spinner";
+import { beginSession, endSession, markSessionInterrupted } from "../../session";
+import { createSessionTools } from "../../session/session-tools";
+import { promptToRetryAiCall } from "../../ai/retry-prompt";
+
+function createReadOnlyTools(executor: ToolExecutor) {
+    const all = createAgentTools(executor);
+    const {
+        create_file: _cf,
+        modify_file: _mf,
+        delete_file: _df,
+        create_folder: _cfo,
+        replace_in_file: _rif,
+        append_to_file: _atf,
+        insert_at_line: _ial,
+        run_command: _rc,
+        run_background_command: _rbc,
+        execute_shell: _es,
+        run_tests: _rt,
+        run_test_file: _rtf,
+        lint_project: _lp,
+        format_project: _fp,
+        ...readOnly
+    } = all;
+    return readOnly;
+}
+
+function asMd(questions: string, answer: string): string {
+    return `## Question\n\n${questions.trim()}\n\n## Answer\n\n${answer.trim()}\n`;
+}
+
+/**
+ * Exponential backoff with jitter.
+ * Base 1s, max 30s: 1s → 2s → 4s → 8s → 16s → 30s (capped)
+ */
+async function backoffDelay(attemptNumber: number): Promise<void> {
+    const baseDelayMs = 1000;
+    const maxDelayMs = 30000;
+    const jitterMs = Math.random() * 500; // ±0ms to 500ms
+    const delayMs = Math.min(maxDelayMs, (1 << attemptNumber) * baseDelayMs + jitterMs);
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+
+export async function runAskMode(preCapturedGoal?: string) {
+    console.log(chalk.bold("\nAsk Mode\n"));
+
+    const goal = preCapturedGoal ?? await text({
+        message: "What would you like the agent to do for you?",
+        placeholder: "Concrete task for this codebase...",
+    });
+
+    if (isCancel(goal) || !goal.trim()) return;
+
+    const config = defaultAgentConfig();
+    config.tools.allowShellExecution = false;
+    config.tools.allowFileModification = false;
+    config.tools.allowFolderCreation = false;
+    config.tools.allowFileCreation = false;
+
+    const tracker = new ActionTracker();
+    const executor = new ToolExecutor(tracker, config);
+
+    const { entry: sessionEntry } = beginSession({
+        workspacePath: config.codebasePath,
+        mode: "ask",
+        goal: goal.trim(),
+    });
+
+    const agent = new ToolLoopAgent({
+        model: getAgentModel(),
+        stopWhen: stepCountIs(25),
+        tools: {
+            ...createReadOnlyTools(executor),
+            ...createWebTools(tracker),
+            ...createSessionTools(config.codebasePath),
+        },
+    });
+
+    // ── System Prompt Injection for Organic Identity ──────────────────────
+    const systemDirective = 
+        "You are Astra, an AI-native development CLI companion tool built to help " +
+        "the user navigate, analyze, and build within their workspace codebase. If the user asks " +
+        "who you are, what your name is, or what model you are running on, you must always identify " +
+        "yourself exclusively as Astra. Do not mention your underlying model architecture or provider.";
+
+    const combinedPrompt = `${systemDirective}\n\nUser Question: ${goal.trim()}`;
+
+    // ── Retry loop with bounded attempt count and exponential backoff ──────
+    const MAX_RETRIES = 5;
+    let result;
+    let attemptCount = 0;
+
+    while (attemptCount < MAX_RETRIES) {
+        try {
+            result = await withSpinner(
+                {
+                    message: "Thinking...",
+                    doneMessage: "here's the answer",
+                    failMessage: "couldn't get an answer",
+                },
+                () =>
+                    agent.generate({
+                        prompt: combinedPrompt,
+                        onStepFinish: ({ toolCalls }) => {
+                            for (const tc of toolCalls) {
+                                const preview = JSON.stringify(tc.input).slice(0, 160);
+                                console.log(
+                                    chalk.cyan("  -"),
+                                    chalk.bold(String(tc.toolName)),
+                                    chalk.dim(preview + (preview.length > 160 ? "..." : "")),
+                                );
+                            }
+                        },
+                    }),
+            );
+            break; // Success — exit retry loop
+        } catch (error) {
+            attemptCount++;
+            const attemptsRemaining = MAX_RETRIES - attemptCount;
+
+            // If out of retries, fail gracefully
+            if (attemptsRemaining <= 0) {
+                console.log(
+                    chalk.red(`\n✗ AI provider error after ${MAX_RETRIES} attempts. Giving up.\n`)
+                );
+                markSessionInterrupted(sessionEntry.id);
+                await endSession(
+                    sessionEntry.id,
+                    tracker,
+                    `Provider error after ${MAX_RETRIES} retries.`,
+                );
+                executor.discardChanges();
+                return;
+            }
+
+            // Ask if user wants to retry
+            const retry = await promptToRetryAiCall(
+                `The answer request hit a provider error (attempt ${attemptCount}/${MAX_RETRIES}).`,
+                error,
+            );
+
+            if (!retry) {
+                markSessionInterrupted(sessionEntry.id);
+                await endSession(
+                    sessionEntry.id,
+                    tracker,
+                    "User cancelled after provider error.",
+                );
+                executor.discardChanges();
+                return;
+            }
+
+            // Apply backoff before next attempt
+            console.log(
+                chalk.dim(
+                    `  Waiting before retry ${attemptCount + 1}/${MAX_RETRIES}...`
+                )
+            );
+            await backoffDelay(attemptCount - 1);
+        }
+    }
+
+    const answer = result!.text.trim() || "(agent returned empty response)";
+
+    console.log("\n" + renderTerminalMarkdown(answer) + "\n");
+
+    const wantsSave = await confirm({
+        message: "Do you want to save this response to a .md file in the current directory?",
+        initialValue: false,
+    });
+
+    if (isCancel(wantsSave) || !wantsSave) {
+        await endSession(sessionEntry.id, tracker, answer);
+        return;
+    }
+
+    const filename = await text({
+        message: "Filename",
+        initialValue: "response.md",
+        validate: (v) => {
+            const s = (v ?? "").trim();
+            if (!s) return "Required";
+            if (s.includes("..") || s.includes("/") || s.includes("\\"))
+                return "Do not specify path in filename";
+            if (!s.toLocaleLowerCase().endsWith(".md"))
+                return "Must end with .md";
+        },
+    });
+
+    if (isCancel(filename)) {
+        await endSession(sessionEntry.id, tracker, answer);
+        return;
+    }
+
+    config.tools.allowFileCreation = true;
+    executor.createFile(filename, asMd(goal, answer));
+    config.tools.allowFileCreation = false;
+
+    const ok = await runApprovalFlow(tracker);
+    if (!ok) {
+        await endSession(sessionEntry.id, tracker, answer);
+        return executor.discardChanges();
+    }
+
+    await withSpinner(
+        {
+            message: "Saving response...",
+            doneMessage: "response saved",
+            failMessage: "save failed",
+        },
+        async () => {
+            executor.applyApprovedFromTracker();
+        },
+    );
+
+    await endSession(sessionEntry.id, tracker, answer);
+    executor.discardChanges();
+}

package/modes/auto.ts

@@ -0,0 +1,88 @@
+import { text } from "@clack/prompts";
+import { generateText, stepCountIs } from "ai";
+import chalk from "chalk";
+import { getAgentModel } from "../ai";
+import { runAgentMode } from "./agent/orchestrator";
+import { runAskMode } from "./ask/orchestrator";
+import { runPlanMode } from "./plan/orchestrator";
+import { runMultiAgentMode } from "./multi/orchestrator";
+import { withSpinner } from "../tui/spinner";
+import { beginSession, endSession } from "../session";
+import { ActionTracker } from "./agent/action-tracker"; // Adjust path if ActionTracker is located elsewhere
+
+export async function runAutoMode() {
+    console.log(chalk.bold("\n  ✨ Auto-Routing Session\n"));
+
+    const goal = await text({
+        message: "What would you like to do?",
+        placeholder: "Type anything (e.g., 'fix the bug in store.ts' or 'explain how this app works')...",
+    });
+
+    if (!goal || typeof goal !== "string" || !goal.trim()) return;
+
+    const trimmedGoal = goal.trim();
+
+    // 1. Initialize and register the "auto" session in your database store
+    const { entry: sessionEntry } = beginSession({
+        workspacePath: process.cwd(),
+        mode: "auto",
+        goal: trimmedGoal,
+    });
+
+    // Create a generic tracker instance to satisfy endSession requirements
+    const autoTracker = new ActionTracker();
+    let routedMode: "agent" | "ask" | "plan" | "multi" = "agent";
+
+    try {
+        routedMode = await withSpinner(
+            {
+                message: "Analysing request intent...",
+                hideTime: true,
+            },
+            async () => {
+                const result = await generateText({
+                    model: getAgentModel(),
+                    stopWhen: stepCountIs(1),
+                    prompt: [
+                        "You are an intent classification router for a development workflow environment.",
+                        "Classify the following user request into exactly one of these 4 options:",
+                        "- 'ask': User is asking questions, needs code explanations, or conceptual help without needing file edits.",
+                        "- 'plan': User wants structural architectural layout designs or step-by-step checklists before writing code.",
+                        "- 'multi': User explicitly requests multi-agent swarms or concurrent pipeline workers.",
+                        "- 'agent': User wants to write code, modify files, delete files, refactor items, or run workspace terminal tasks.",
+                        "",
+                        `Request: "${trimmedGoal}"`,
+                        "",
+                        "Respond with exactly one word from the choices: ask, plan, multi, agent. Do not include markdown formatting or punctuation.",
+                    ].join("\n"),
+                });
+
+                const word = result.text.trim().toLowerCase();
+                if (["ask", "plan", "multi", "agent"].includes(word)) {
+                    return word as "agent" | "ask" | "plan" | "multi";
+                }
+                return "agent";
+            }
+        );
+    } catch {
+        routedMode = "agent";
+    }
+
+    // 2. Finalize and log the router's decision phase into the store history trail
+    await endSession(
+        sessionEntry.id, 
+        autoTracker, 
+        `Auto-router successfully mapped intent to down-stream [${routedMode}] engine.`
+    );
+
+    // 3. Execute the target handler, forwarding the pre-captured prompt input string
+    if (routedMode === "agent") {
+        await runAgentMode(trimmedGoal);
+    } else if (routedMode === "ask") {
+        await runAskMode(trimmedGoal);
+    } else if (routedMode === "plan") {
+        await runPlanMode(trimmedGoal);
+    } else if (routedMode === "multi") {
+        await runMultiAgentMode(trimmedGoal);
+    }
+}

package/modes/cli.ts

@@ -0,0 +1,43 @@
+import chalk from "chalk";
+import {select, isCancel} from "@clack/prompts"
+import { runAgentMode } from "./agent/orchestrator";
+import { runAskMode } from "./ask/orchestrator";
+import { runPlanMode } from "./plan/orchestrator";
+import { runMultiAgentMode } from "./multi/orchestrator";
+import { runAutoMode } from "./auto";
+
+export async function runCliMode () {
+    while(true){
+        const mode = await select({
+            message: "Choose CLI mode:",
+            options: [
+                {value: "auto", label:"Auto Mode"},
+                {value: "agent", label:"Agent Mode"},
+                {value: "plan", label:"Plan Mode"},
+                {value: "ask", label:"Ask Mode"},
+                {value: "multi", label: "Multi-Agent Mode"},
+                {value: "back", label:" ⬅ Back to main menu"},
+            ]
+        })
+        if(isCancel(mode) || mode === "back") return
+
+        if(mode==="agent"){
+            await runAgentMode()
+        }
+        else if(mode==="plan"){
+            await runPlanMode()
+        }
+        else if(mode==="ask"){
+            await runAskMode()
+        }
+        else if(mode==="multi"){
+            await runMultiAgentMode()
+        }
+        else if(mode==="auto"){
+            await runAutoMode()
+        }
+        if(mode!=="agent" && mode!=="plan" && mode!=="ask" && mode!=="multi" && mode!="auto"){
+            console.log(chalk.yellow('\n This mode is not implemented yet. \n'))
+        }
+    }
+}