astrocode-workflow 0.3.0 → 0.3.2

package/dist/src/index.js

@@ -0,0 +1,308 @@
+import { loadAstrocodeConfig } from "./config/loader";
+import { createConfigHandler } from "./config/config-handler";
+import { openSqlite, configurePragmas, ensureSchema, getSchemaVersion } from "./state/db";
+import { getAstroPaths, ensureAstroDirs } from "./shared/paths";
+import { createAstroTools } from "./tools";
+import { createContinuationEnforcer } from "./hooks/continuation-enforcer";
+import { createToolOutputTruncatorHook } from "./hooks/tool-output-truncator";
+import { createInjectProvider } from "./hooks/inject-provider";
+import { createToastManager } from "./ui/toasts";
+import { createAstroAgents } from "./agents/registry";
+import { info, warn } from "./shared/log";
+import { acquireRepoLock } from "./state/repo-lock";
+// Safe config cloning with structuredClone preference (fallback for older Node versions)
+// CONTRACT: Config is guaranteed JSON-serializable (enforced by loadAstrocodeConfig validation)
+const cloneConfig = (v) => {
+    // Prefer structuredClone when available (keeps more types)
+    if (typeof globalThis.structuredClone === "function") {
+        return globalThis.structuredClone(v);
+    }
+    // Fallback: JSON clone (safe since config is validated as JSON-serializable)
+    return JSON.parse(JSON.stringify(v));
+};
+// Minimal config defaults for limited-mode fallback
+const applyMinimalConfigDefaults = (cfg) => {
+    if (!cfg || typeof cfg !== "object")
+        return;
+    if (!Array.isArray(cfg.disabled_hooks))
+        cfg.disabled_hooks = [];
+    if (!cfg.ui || typeof cfg.ui !== "object")
+        cfg.ui = {};
+    if (!cfg.ui.toasts || typeof cfg.ui.toasts !== "object")
+        cfg.ui.toasts = { enabled: false };
+    if (typeof cfg.ui.toasts.enabled !== "boolean")
+        cfg.ui.toasts.enabled = false;
+};
+const Astrocode = async (ctx) => {
+    if (!ctx.directory || typeof ctx.directory !== "string") {
+        throw new Error("Astrocode requires ctx.directory to be a string repo root.");
+    }
+    const repoRoot = ctx.directory;
+    // Acquire exclusive repo lock to prevent multiple processes from corrupting the database
+    const lockPath = `${repoRoot}/.astro/astro.lock`;
+    const repoLock = acquireRepoLock(lockPath);
+    // Always load config first - this provides defaults even in limited mode
+    let pluginConfig;
+    try {
+        pluginConfig = loadAstrocodeConfig(repoRoot);
+    }
+    catch (e) {
+        warn(`Config loading failed, using minimal defaults.`, { err: e });
+        // Fallback to minimal safe defaults when config loading fails
+        pluginConfig = {
+            disabled_hooks: [],
+            disabled_agents: [],
+            determinism: { mode: "on", strict_stage_order: true },
+            db: {
+                path: ".astro/astro.db",
+                busy_timeout_ms: 5000,
+                pragmas: {},
+                schema_version_required: 2,
+                allow_auto_migrate: true,
+                fail_on_downgrade: true,
+            },
+            ui: {
+                toasts: { enabled: true, throttle_ms: 1500, show_run_started: true, show_stage_started: true, show_stage_completed: true, show_stage_failed: true, show_run_completed: true, show_auto_continue: true },
+            },
+            agents: {
+                orchestrator_name: "Astro",
+                stage_agent_names: { frame: "Frame", plan: "Plan", spec: "Spec", implement: "Implement", review: "Review", verify: "Verify", close: "Close" },
+                librarian_name: "Librarian",
+                explore_name: "Explore",
+                qa_name: "QA",
+                agent_variant_overrides: {},
+            },
+            workflow: {
+                default_mode: "step",
+                default_max_steps: 10,
+                loop_max_steps_hard_cap: 100,
+                evidence_required: { verify: false },
+            },
+            permissions: { enforce_task_tool_restrictions: false, deny_delegate_task_in_subagents: false },
+        };
+    }
+    // Always ensure .astro directories exist, even in limited mode
+    const paths = getAstroPaths(repoRoot, pluginConfig.db.path);
+    ensureAstroDirs(paths);
+    let db = null;
+    let agents = undefined;
+    let configHandler = async () => {
+        throw new Error("ConfigHandler called before initialization");
+    };
+    let continuation = null;
+    let truncatorHook = null;
+    let injectProvider = null;
+    let toastManager = null;
+    let limitedModeReason = null;
+    let limitedMode = false;
+    // Phase 1: Database initialization (only DB-related operations)
+    try {
+        db = openSqlite(paths.dbPath, { busyTimeoutMs: pluginConfig.db.busy_timeout_ms });
+        configurePragmas(db, pluginConfig.db.pragmas);
+        // Policy enforced in harness; db layer is mechanics only (migration + structural schema creation)
+        ensureSchema(db, { allowAutoMigrate: pluginConfig.db.allow_auto_migrate });
+        // Harness-exclusive: enforce schema version requirement
+        // Explicitly enforce schema version requirement (harness-level policy)
+        const required = pluginConfig.db.schema_version_required;
+        let current = getSchemaVersion(db);
+        if (current < required) {
+            if (!pluginConfig.db.allow_auto_migrate) {
+                // Migration disabled - enter limited mode
+                limitedModeReason = { code: "schema_too_old", details: { current, required } };
+                warn("Entering limited mode (schema too old, migration disabled).", {
+                    dbPath: paths.dbPath,
+                    schemaCurrent: current,
+                    schemaRequired: required,
+                    failOnDowngrade: pluginConfig.db.fail_on_downgrade,
+                    allowAutoMigrate: pluginConfig.db.allow_auto_migrate,
+                });
+                db.close?.();
+                db = null;
+            }
+            else {
+                // Migration allowed - re-run ensureSchema (idempotent) in case first call failed
+                ensureSchema(db, { allowAutoMigrate: true });
+                current = getSchemaVersion(db);
+                if (current < required) {
+                    // Migration failed - enter limited mode
+                    limitedModeReason = { code: "schema_migration_failed", details: { current, required } };
+                    warn("Entering limited mode (schema migration failed).", {
+                        dbPath: paths.dbPath,
+                        schemaCurrent: current,
+                        schemaRequired: required,
+                        failOnDowngrade: pluginConfig.db.fail_on_downgrade,
+                        allowAutoMigrate: pluginConfig.db.allow_auto_migrate,
+                    });
+                    db.close?.();
+                    db = null;
+                }
+            }
+        }
+        else if (current > required && pluginConfig.db.fail_on_downgrade) {
+            limitedModeReason = { code: "schema_downgrade", details: { current, required } };
+            warn("Entering limited mode (schema downgrade).", {
+                dbPath: paths.dbPath,
+                schemaCurrent: current,
+                schemaRequired: required,
+                failOnDowngrade: pluginConfig.db.fail_on_downgrade,
+                allowAutoMigrate: pluginConfig.db.allow_auto_migrate,
+            });
+            db.close?.();
+            db = null;
+        }
+    }
+    catch (e) {
+        // True database initialization failure - enter limited mode
+        warn(`Database initialization failed. Entering limited mode with reduced functionality.`, { err: e });
+        // Clean up partially-opened database connection
+        if (db && typeof db.close === "function") {
+            try {
+                db.close();
+            }
+            catch (closeErr) {
+                // Ignore close errors during cleanup
+            }
+        }
+        db = null;
+        limitedModeReason = { code: "db_init_failed", details: e };
+    }
+    // Derive limited mode flag once for single source of truth
+    limitedMode = db === null;
+    // Single runtime state object for downstream components
+    const runtime = { db, limitedMode, limitedModeReason };
+    // Phase 2: Component initialization (based on DB availability)
+    if (!limitedMode) {
+        // Normal mode: DB available, create all components
+        try {
+            agents = createAstroAgents({ pluginConfig });
+            // Database initialized successfully
+            info("Database initialized successfully. Plugin ready.");
+            configHandler = createConfigHandler({ pluginConfig });
+            continuation = createContinuationEnforcer({ ctx, config: pluginConfig, runtime });
+            truncatorHook = createToolOutputTruncatorHook({ ctx, config: pluginConfig, runtime });
+            injectProvider = createInjectProvider({ ctx, config: pluginConfig, runtime });
+            toastManager = createToastManager({ ctx, throttleMs: pluginConfig.ui.toasts.throttle_ms });
+        }
+        catch (e) {
+            // Component failure with working DB → fail plugin boot
+            const err = e instanceof Error ? e : new Error(String(e));
+            throw new Error("Plugin initialization failed after successful database setup", { cause: err });
+        }
+    }
+    else {
+        // Limited mode: DB unavailable, create minimal components
+        // Clone the already-loaded config to avoid mutating shared state, then apply limited mode overrides
+        pluginConfig = cloneConfig(pluginConfig);
+        // Apply limited-mode config overrides BEFORE creating any components
+        pluginConfig.disabled_hooks = Array.from(new Set([...(pluginConfig.disabled_hooks || []), "continuation-enforcer", "tool-output-truncator", "inject-provider"]));
+        pluginConfig.ui.toasts.enabled = false;
+        // Show one-shot limited mode notification via logging (keeps toast policy consistent)
+        const reasonMessage = limitedModeReason ?
+            (limitedModeReason.code === "db_init_failed" ? "Database initialization failed. Check native deps or run astro_init." :
+                limitedModeReason.code === "schema_too_old" ? "Database schema too old and migration disabled." :
+                    limitedModeReason.code === "schema_downgrade" ? "Database schema newer than plugin (downgrade detected)." :
+                        limitedModeReason.code === "schema_migration_failed" ? "Database schema migration failed." :
+                            "Database unavailable.") :
+            "Database unavailable.";
+        warn(`Astrocode: Limited Mode - ${reasonMessage}`, { dbPath: paths.dbPath });
+        // Create limited functionality (no global toast manager since toasts are disabled)
+        try {
+            configHandler = createConfigHandler({ pluginConfig });
+        }
+        catch (e) {
+            warn("Limited Mode: config handler unavailable", { err: e });
+            configHandler = async (config) => {
+                applyMinimalConfigDefaults(config);
+            };
+        }
+        continuation = null;
+        truncatorHook = null;
+        injectProvider = null;
+        toastManager = null; // No global toast manager in limited mode
+    }
+    // Helper for hook enablement checks (config is now finalized)
+    const hookEnabled = (key) => !pluginConfig.disabled_hooks?.includes(key);
+    // Create tools once with final state (limited mode gets DB-safe tool implementations)
+    const tools = createAstroTools({ ctx, config: pluginConfig, agents, runtime });
+    return {
+        name: "astrocode-harness",
+        // Register agents
+        agents,
+        // Merge agents + slash commands into system config
+        config: configHandler,
+        // Register tools
+        tool: tools,
+        // Limit created subagents from spawning more subagents (OMO-style).
+        "tool.execute.before": async (input, output) => {
+            if (!pluginConfig.permissions.enforce_task_tool_restrictions)
+                return;
+            if (input?.tool !== "task")
+                return;
+            const baseArgs = (output && typeof output === "object" ? output.args : undefined) ?? {};
+            const baseTools = (baseArgs && typeof baseArgs === "object" && baseArgs.tools && typeof baseArgs.tools === "object")
+                ? baseArgs.tools
+                : {};
+            const nextTools = { ...baseTools };
+            if (pluginConfig.permissions.deny_delegate_task_in_subagents) {
+                nextTools.delegate_task = false;
+            }
+            const nextArgs = { ...baseArgs, tools: nextTools };
+            // Back-compat: mutate if possible
+            if (output && typeof output === "object" && !Object.isFrozen(output)) {
+                output.args = nextArgs;
+            }
+            // Forward-compat: return conservative merge
+            if (output && typeof output === "object") {
+                return { ...output, args: nextArgs };
+            }
+            return { args: nextArgs };
+        },
+        "tool.execute.after": async (input, output) => {
+            // Truncate huge tool outputs to artifacts
+            if (truncatorHook && hookEnabled("tool-output-truncator")) {
+                await truncatorHook(input, output ?? null);
+            }
+            // Schedule continuation (do not immediately spam)
+            if (continuation && hookEnabled("continuation-enforcer")) {
+                await continuation.onToolAfter(input);
+            }
+            return output;
+        },
+        "chat.message": async (input, output) => {
+            if (injectProvider && hookEnabled("inject-provider")) {
+                await injectProvider.onChatMessage(input);
+            }
+            if (continuation && hookEnabled("continuation-enforcer")) {
+                await continuation.onChatMessage(input);
+            }
+            return output;
+        },
+        event: async (input) => {
+            if (continuation && hookEnabled("continuation-enforcer")) {
+                await continuation.onEvent(input);
+            }
+        },
+        // Best-effort cleanup
+        close: async () => {
+            // Release repo lock first (important for process termination)
+            repoLock.release();
+            if (db && typeof db.close === "function") {
+                try {
+                    db.close();
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (toastManager && pluginConfig.ui.toasts.enabled) {
+                try {
+                    await toastManager.show({ title: "Astrocode", message: "Plugin closed", variant: "info" });
+                }
+                catch {
+                    // ignore
+                }
+            }
+        },
+    };
+};
+export default Astrocode;

package/dist/src/shared/deep-merge.d.ts

@@ -0,0 +1,8 @@
+export declare function isPlainObject(v: unknown): v is Record<string, unknown>;
+/**
+ * Deep merge:
+ * - objects merge recursively
+ * - arrays replace
+ * - primitives overwrite
+ */
+export declare function deepMerge<T>(base: T, patch: Partial<T>): T;

package/dist/src/shared/deep-merge.js

@@ -0,0 +1,25 @@
+export function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+ * Deep merge:
+ * - objects merge recursively
+ * - arrays replace
+ * - primitives overwrite
+ */
+export function deepMerge(base, patch) {
+    if (!isPlainObject(base) || !isPlainObject(patch)) {
+        return patch ?? base;
+    }
+    const out = { ...base };
+    for (const [k, v] of Object.entries(patch)) {
+        const cur = out[k];
+        if (isPlainObject(cur) && isPlainObject(v)) {
+            out[k] = deepMerge(cur, v);
+        }
+        else {
+            out[k] = v;
+        }
+    }
+    return out;
+}

package/dist/src/shared/hash.d.ts

@@ -0,0 +1 @@
+export declare function sha256Hex(input: string | Buffer): string;

package/dist/src/shared/hash.js

@@ -0,0 +1,4 @@
+import { createHash } from "node:crypto";
+export function sha256Hex(input) {
+    return createHash("sha256").update(input).digest("hex");
+}

package/dist/src/shared/log.d.ts

@@ -0,0 +1,7 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export declare function setLogLevel(level: LogLevel): void;
+export declare function log(level: LogLevel, message: string, meta?: unknown): void;
+export declare const debug: (msg: string, meta?: unknown) => void;
+export declare const info: (msg: string, meta?: unknown) => void;
+export declare const warn: (msg: string, meta?: unknown) => void;
+export declare const error: (msg: string, meta?: unknown) => void;

package/dist/src/shared/log.js

@@ -0,0 +1,24 @@
+let CURRENT_LEVEL = process.env.ASTRO_LOG_LEVEL ?? "info";
+const ORDER = { debug: 10, info: 20, warn: 30, error: 40 };
+export function setLogLevel(level) {
+    CURRENT_LEVEL = level;
+}
+function shouldLog(level) {
+    return ORDER[level] >= ORDER[CURRENT_LEVEL];
+}
+export function log(level, message, meta) {
+    if (!shouldLog(level))
+        return;
+    const prefix = `[astrocode:${level}]`;
+    if (meta === undefined) {
+        // eslint-disable-next-line no-console
+        console.log(prefix, message);
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log(prefix, message, meta);
+}
+export const debug = (msg, meta) => log("debug", msg, meta);
+export const info = (msg, meta) => log("info", msg, meta);
+export const warn = (msg, meta) => log("warn", msg, meta);
+export const error = (msg, meta) => log("error", msg, meta);

package/dist/src/shared/metrics.d.ts

@@ -0,0 +1,66 @@
+export interface TransactionMetrics {
+    startTime: number;
+    duration: number;
+    success: boolean;
+    nestedDepth: number;
+    operation?: string;
+}
+export interface InjectionMetrics {
+    sessionId: string;
+    attempts: number;
+    duration: number;
+    success: boolean;
+    agent?: string;
+}
+export interface SystemMetrics {
+    transactions: TransactionMetrics[];
+    injections: InjectionMetrics[];
+    errors: Array<{
+        type: string;
+        message: string;
+        timestamp: number;
+    }>;
+}
+declare class MetricsCollector {
+    private transactions;
+    private injections;
+    private errors;
+    private maxEntries;
+    recordTransaction(metrics: TransactionMetrics): void;
+    recordInjection(metrics: InjectionMetrics): void;
+    recordError(type: string, message: string): void;
+    getMetrics(): SystemMetrics;
+    getTransactionStats(): {
+        total: number;
+        successful: number;
+        failed: number;
+        successRate: number;
+        avgDuration: number;
+        avgNestedDepth: number;
+        minDuration: number;
+        maxDuration: number;
+    };
+    getInjectionStats(): {
+        total: number;
+        successful: number;
+        failed: number;
+        successRate: number;
+        avgAttempts: number;
+        avgDuration: number;
+        totalRetries: number;
+    };
+    clear(): void;
+}
+export declare const metrics: MetricsCollector;
+export declare function recordTransaction(metricsData: Omit<TransactionMetrics, 'startTime' | 'duration' | 'success'>): any;
+export declare function recordInjection(metricsData: Omit<InjectionMetrics, 'duration' | 'success'>): {
+    start(): {
+        startTime: number;
+        agent?: string;
+        sessionId: string;
+        attempts: number;
+    };
+    end(startData: any, success: boolean): void;
+};
+export declare function recordError(type: string, message: string): void;
+export {};

package/dist/src/shared/metrics.js

@@ -0,0 +1,112 @@
+// src/shared/metrics.ts
+class MetricsCollector {
+    transactions = [];
+    injections = [];
+    errors = [];
+    maxEntries = 1000; // Keep last 1000 entries per type
+    recordTransaction(metrics) {
+        this.transactions.push(metrics);
+        if (this.transactions.length > this.maxEntries) {
+            this.transactions.shift();
+        }
+    }
+    recordInjection(metrics) {
+        this.injections.push(metrics);
+        if (this.injections.length > this.maxEntries) {
+            this.injections.shift();
+        }
+    }
+    recordError(type, message) {
+        this.errors.push({ type, message, timestamp: Date.now() });
+        if (this.errors.length > this.maxEntries) {
+            this.errors.shift();
+        }
+    }
+    getMetrics() {
+        return {
+            transactions: [...this.transactions],
+            injections: [...this.injections],
+            errors: [...this.errors],
+        };
+    }
+    getTransactionStats() {
+        const txs = this.transactions;
+        if (txs.length === 0)
+            return null;
+        const successful = txs.filter(t => t.success);
+        const failed = txs.filter(t => !t.success);
+        return {
+            total: txs.length,
+            successful: successful.length,
+            failed: failed.length,
+            successRate: successful.length / txs.length,
+            avgDuration: txs.reduce((sum, t) => sum + t.duration, 0) / txs.length,
+            avgNestedDepth: txs.reduce((sum, t) => sum + t.nestedDepth, 0) / txs.length,
+            minDuration: Math.min(...txs.map(t => t.duration)),
+            maxDuration: Math.max(...txs.map(t => t.duration)),
+        };
+    }
+    getInjectionStats() {
+        const injections = this.injections;
+        if (injections.length === 0)
+            return null;
+        const successful = injections.filter(i => i.success);
+        const failed = injections.filter(i => !i.success);
+        return {
+            total: injections.length,
+            successful: successful.length,
+            failed: failed.length,
+            successRate: successful.length / injections.length,
+            avgAttempts: injections.reduce((sum, i) => sum + i.attempts, 0) / injections.length,
+            avgDuration: injections.reduce((sum, i) => sum + i.duration, 0) / injections.length,
+            totalRetries: injections.reduce((sum, i) => sum + Math.max(0, i.attempts - 1), 0),
+        };
+    }
+    clear() {
+        this.transactions = [];
+        this.injections = [];
+        this.errors = [];
+    }
+}
+// Global singleton
+export const metrics = new MetricsCollector();
+// Convenience functions
+export function recordTransaction(metricsData) {
+    return {
+        start() {
+            return {
+                ...metricsData,
+                startTime: Date.now(),
+            };
+        },
+        end(startData, success) {
+            const duration = Date.now() - startData.startTime;
+            metrics.recordTransaction({
+                ...startData,
+                duration,
+                success,
+            });
+        },
+    };
+}
+export function recordInjection(metricsData) {
+    return {
+        start() {
+            return {
+                ...metricsData,
+                startTime: Date.now(),
+            };
+        },
+        end(startData, success) {
+            const duration = Date.now() - startData.startTime;
+            metrics.recordInjection({
+                ...startData,
+                duration,
+                success,
+            });
+        },
+    };
+}
+export function recordError(type, message) {
+    metrics.recordError(type, message);
+}

package/dist/src/shared/model-tuning.d.ts

@@ -0,0 +1,9 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+export type AstroCognitionPreset = "orchestrator" | "frame" | "plan" | "spec" | "implement" | "review" | "verify" | "close" | "utility";
+/**
+ * OMO-style: if GPT model => reasoningEffort/textVerbosity.
+ * Otherwise => Anthropic-style thinking budget.
+ *
+ * Not all providers honor these fields; safe to include.
+ */
+export declare function applyModelTuning(base: AgentConfig, preset: AstroCognitionPreset): AgentConfig;

package/dist/src/shared/model-tuning.js

@@ -0,0 +1,28 @@
+import { isGptModel } from "../agents/types";
+/**
+ * OMO-style: if GPT model => reasoningEffort/textVerbosity.
+ * Otherwise => Anthropic-style thinking budget.
+ *
+ * Not all providers honor these fields; safe to include.
+ */
+export function applyModelTuning(base, preset) {
+    const model = base.model ?? "";
+    if (!model)
+        return base;
+    if (isGptModel(model)) {
+        const reasoningEffort = preset === "orchestrator" ? "medium"
+            : preset === "implement" ? "high"
+                : "medium";
+        const textVerbosity = preset === "orchestrator" ? "low"
+            : preset === "review" ? "high"
+                : "medium";
+        const { thinking, ...rest } = base;
+        return { ...rest, reasoningEffort, textVerbosity };
+    }
+    const budgetTokens = preset === "implement" ? 32_000
+        : preset === "review" ? 24_000
+            : preset === "orchestrator" ? 16_000
+                : 12_000;
+    const { reasoningEffort, textVerbosity, ...rest } = base;
+    return { ...rest, thinking: { type: "enabled", budgetTokens } };
+}

package/dist/src/shared/paths.d.ts

@@ -0,0 +1,19 @@
+/** Normalize to posix-like separators for DB paths. */
+export declare function toPosix(p: string): string;
+export declare function ensureDir(p: string): void;
+export declare function joinRepo(root: string, ...parts: string[]): string;
+export type AstroPaths = {
+    repoRoot: string;
+    astroRoot: string;
+    dbPath: string;
+    runsDir: string;
+    specPath: string;
+    toolOutputDir: string;
+    configPathPreferred: string;
+    configPathFallback: string;
+};
+export declare function getAstroPaths(repoRoot: string, dbPathOverride?: string): AstroPaths;
+export declare function ensureAstroDirs(paths: AstroPaths): void;
+export declare function runDir(paths: AstroPaths, runId: string): string;
+export declare function stageDir(paths: AstroPaths, runId: string, stageKey: string): string;
+export declare function assertInsideAstro(repoRoot: string, filePath: string): void;