astrocode-workflow 0.0.1

package/src/shared/log.ts

@@ -0,0 +1,30 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+let CURRENT_LEVEL: LogLevel = (process.env.ASTRO_LOG_LEVEL as LogLevel) ?? "info";
+
+const ORDER: Record<LogLevel, number> = { debug: 10, info: 20, warn: 30, error: 40 };
+
+export function setLogLevel(level: LogLevel) {
+  CURRENT_LEVEL = level;
+}
+
+function shouldLog(level: LogLevel): boolean {
+  return ORDER[level] >= ORDER[CURRENT_LEVEL];
+}
+
+export function log(level: LogLevel, message: string, meta?: unknown) {
+  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: string, meta?: unknown) => log("debug", msg, meta);
+export const info = (msg: string, meta?: unknown) => log("info", msg, meta);
+export const warn = (msg: string, meta?: unknown) => log("warn", msg, meta);
+export const error = (msg: string, meta?: unknown) => log("error", msg, meta);

package/src/shared/model-tuning.ts

@@ -0,0 +1,48 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import { isGptModel } from "../agents/types";
+
+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 function applyModelTuning(base: AgentConfig, preset: AstroCognitionPreset): AgentConfig {
+  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 as any;
+    return { ...rest, reasoningEffort, textVerbosity } as AgentConfig;
+  }
+
+  const budgetTokens =
+    preset === "implement" ? 32_000
+    : preset === "review" ? 24_000
+    : preset === "orchestrator" ? 16_000
+    : 12_000;
+
+  const { reasoningEffort, textVerbosity, ...rest } = base as any;
+  return { ...rest, thinking: { type: "enabled", budgetTokens } } as AgentConfig;
+}

package/src/shared/paths.ts

@@ -0,0 +1,70 @@
+import path from "node:path";
+import fs from "node:fs";
+
+/** Normalize to posix-like separators for DB paths. */
+export function toPosix(p: string): string {
+  return p.split(path.sep).join("/");
+}
+
+export function ensureDir(p: string) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+export function joinRepo(root: string, ...parts: string[]): string {
+  return path.join(root, ...parts);
+}
+
+export type AstroPaths = {
+  repoRoot: string;
+  astroRoot: string;
+  dbPath: string;
+  runsDir: string;
+  specPath: string;
+  toolOutputDir: string;
+  configPathPreferred: string;
+  configPathFallback: string;
+};
+
+export function getAstroPaths(repoRoot: string, dbPathOverride?: string): AstroPaths {
+  const astroRoot = joinRepo(repoRoot, ".astro");
+  const runsDir = joinRepo(repoRoot, ".astro", "runs");
+  const dbPath = dbPathOverride ? joinRepo(repoRoot, dbPathOverride) : joinRepo(repoRoot, ".astro", "astro.db");
+  const specPath = joinRepo(repoRoot, ".astro", "spec.md");
+  const toolOutputDir = joinRepo(repoRoot, ".astro", "tool_output");
+  return {
+    repoRoot,
+    astroRoot,
+    dbPath,
+    runsDir,
+    specPath,
+    toolOutputDir,
+    configPathPreferred: joinRepo(repoRoot, ".astro", "astrocode.config.jsonc"),
+    configPathFallback: joinRepo(repoRoot, "astrocode.config.jsonc"),
+  };
+}
+
+export function ensureAstroDirs(paths: AstroPaths) {
+  ensureDir(paths.astroRoot);
+  ensureDir(paths.runsDir);
+  ensureDir(paths.toolOutputDir);
+}
+
+export function runDir(paths: AstroPaths, runId: string): string {
+  return joinRepo(paths.repoRoot, ".astro", "runs", runId);
+}
+
+export function stageDir(paths: AstroPaths, runId: string, stageKey: string): string {
+  return joinRepo(paths.repoRoot, ".astro", "runs", runId, stageKey);
+}
+
+export function assertInsideAstro(repoRoot: string, filePath: string) {
+  const absRepo = path.resolve(repoRoot);
+  const abs = path.resolve(filePath);
+  const astroRoot = path.resolve(path.join(repoRoot, ".astro"));
+  if (!abs.startsWith(astroRoot + path.sep) && abs !== astroRoot) {
+    throw new Error(`Refusing to write outside .astro: ${filePath}`);
+  }
+  if (!abs.startsWith(absRepo + path.sep) && abs !== absRepo) {
+    throw new Error(`Refusing to write outside repo root: ${filePath}`);
+  }
+}

package/src/shared/text.ts

@@ -0,0 +1,20 @@
+export function normalizeNewlines(s: string): string {
+  return s.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+export function clampLines(md: string, maxLines: number): string {
+  const lines = normalizeNewlines(md).split("\n");
+  if (lines.length <= maxLines) return md.trimEnd();
+  return lines.slice(0, maxLines).join("\n").trimEnd() + "\n…";
+}
+
+export function clampChars(s: string, maxChars: number): string {
+  if (s.length <= maxChars) return s;
+  return s.slice(0, maxChars) + "\n…(truncated)";
+}
+
+export function stripCodeFences(md: string): string {
+  // Light helper: remove surrounding triple backticks if present
+  const m = md.match(/^```[a-zA-Z0-9_-]*\n([\s\S]*)\n```\s*$/);
+  return m ? m[1] : md;
+}

package/src/shared/time.ts

@@ -0,0 +1,3 @@
+export function nowISO(): string {
+  return new Date().toISOString();
+}

package/src/shims.node.d.ts

@@ -0,0 +1,20 @@
+/*
+  Minimal Node.js type shims so this package can compile in environments
+  where @types/node is not installed (e.g., offline installs).
+
+  Keep this file tiny on purpose: only add declarations that are actually
+  referenced in the codebase.
+*/
+
+declare var require: any;
+
+declare var process: {
+  env: Record<string, string | undefined>;
+  cwd?: () => string;
+};
+
+declare var __dirname: string;
+
+declare class Buffer {
+  static from(input: any, encoding?: string): Buffer;
+}

package/src/state/adapters/index.ts

@@ -0,0 +1,155 @@
+import { info, warn } from "../../shared/log";
+
+export interface DatabaseConnection {
+  pragma(sql: string): void;
+  exec(sql: string): void;
+  prepare(sql: string): Statement;
+  close(): void;
+}
+
+export interface Statement {
+  run(...params: any[]): { changes: number; lastInsertRowid: any };
+  get(...params: any[]): any;
+  all(...params: any[]): any[];
+}
+
+export interface DatabaseAdapter {
+  isAvailable(): boolean;
+  open(path: string, opts?: { busyTimeoutMs?: number }): DatabaseConnection;
+}
+
+// Mock adapter for when no database is available
+export class MockDatabaseAdapter implements DatabaseAdapter {
+  isAvailable(): boolean {
+    return true; // Mock is always available
+  }
+
+  open(): DatabaseConnection {
+    warn("Using mock database - no persistence available");
+    return {
+      pragma: () => {},
+      exec: () => {},
+      prepare: () => ({
+        run: () => ({ changes: 0, lastInsertRowid: null }),
+        get: () => null,
+        all: () => []
+      }),
+      close: () => {}
+    };
+  }
+}
+
+// Bun SQLite adapter - singleton pattern to avoid multiple initializations
+let bunDatabase: any = null;
+let bunDatabaseInitialized = false;
+
+function initializeBunDatabase(): any {
+  if (bunDatabaseInitialized) {
+    return bunDatabase;
+  }
+
+  bunDatabaseInitialized = true;
+
+  try {
+    const isBun = typeof (globalThis as any).Bun !== 'undefined';
+    if (isBun) {
+      const { Database } = require('bun:sqlite');
+      bunDatabase = Database;
+    }
+  } catch (e) {
+    // bun:sqlite not available
+  }
+
+  return bunDatabase;
+}
+
+// Bun SQLite adapter
+export class BunSqliteAdapter implements DatabaseAdapter {
+  isAvailable(): boolean {
+    return !!initializeBunDatabase();
+  }
+
+  open(path: string, opts?: { busyTimeoutMs?: number }): DatabaseConnection {
+    const Database = initializeBunDatabase();
+    if (!Database) {
+      throw new Error("bun:sqlite not available");
+    }
+
+    const db = new Database(path);
+
+    // Configure database
+    if (opts?.busyTimeoutMs) {
+      db.exec(`PRAGMA busy_timeout = ${opts.busyTimeoutMs}`);
+    }
+
+    return {
+      pragma: (sql: string) => db.exec(`PRAGMA ${sql}`),
+      exec: (sql: string) => db.exec(sql),
+      prepare: (sql: string) => {
+        const stmt = db.prepare(sql);
+        return {
+          run: (...params: any[]) => stmt.run(...params),
+          get: (...params: any[]) => stmt.get(...params),
+          all: (...params: any[]) => stmt.all(...params)
+        };
+      },
+      close: () => db.close()
+    };
+  }
+}
+
+// Better SQLite3 adapter
+export class BetterSqliteAdapter implements DatabaseAdapter {
+  private Database: any = null;
+
+  constructor() {
+    try {
+      this.Database = require("better-sqlite3");
+    } catch (e) {
+      // better-sqlite3 not available
+    }
+  }
+
+  isAvailable(): boolean {
+    return !!this.Database;
+  }
+
+  open(path: string, opts?: { busyTimeoutMs?: number }): DatabaseConnection {
+    if (!this.Database) {
+      throw new Error("better-sqlite3 not available");
+    }
+
+    const db = new this.Database(path);
+
+    // Set busy timeout if specified
+    if (opts?.busyTimeoutMs) {
+      db.pragma(`busy_timeout = ${opts.busyTimeoutMs}`);
+    }
+
+    return {
+      pragma: (sql: string) => db.pragma(sql.replace('PRAGMA ', '')),
+      exec: (sql: string) => db.exec(sql),
+      prepare: (sql: string) => db.prepare(sql),
+      close: () => db.close()
+    };
+  }
+}
+
+// Factory function to create the appropriate adapter
+export function createDatabaseAdapter(): DatabaseAdapter {
+  const isBun = typeof (globalThis as any).Bun !== 'undefined';
+
+  if (isBun) {
+    const adapter = new BunSqliteAdapter();
+    if (adapter.isAvailable()) {
+      return adapter;
+    }
+    throw new Error("Bun runtime detected but bun:sqlite not available");
+  } else {
+    const adapter = new BetterSqliteAdapter();
+    if (adapter.isAvailable()) {
+      return adapter;
+    }
+    throw new Error("Node.js runtime detected but better-sqlite3 not available");
+  }
+}

package/src/state/db.ts

@@ -0,0 +1,105 @@
+import fs from "node:fs";
+import path from "node:path";
+import { SCHEMA_SQL, SCHEMA_VERSION } from "./schema";
+import { nowISO } from "../shared/time";
+import { info, warn } from "../shared/log";
+import { createDatabaseAdapter, DatabaseConnection } from "./adapters";
+
+export type SqliteDb = DatabaseConnection;
+
+/** Ensure directory exists for a file path. */
+function ensureParentDir(filePath: string) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+export function openSqlite(dbPath: string, opts?: { busyTimeoutMs?: number }): SqliteDb {
+  ensureParentDir(dbPath);
+  const adapter = createDatabaseAdapter();
+  const db = adapter.open(dbPath, opts);
+  return db;
+}
+
+export function configurePragmas(
+  db: SqliteDb,
+  pragmas: {
+    journal_mode?: "WAL" | "DELETE";
+    synchronous?: "NORMAL" | "FULL" | "OFF";
+    foreign_keys?: boolean;
+    temp_store?: "DEFAULT" | "MEMORY" | "FILE";
+  }
+) {
+  if (pragmas.journal_mode) db.pragma(`journal_mode = ${pragmas.journal_mode}`);
+  if (pragmas.synchronous) db.pragma(`synchronous = ${pragmas.synchronous}`);
+  if (typeof pragmas.foreign_keys === "boolean") db.pragma(`foreign_keys = ${pragmas.foreign_keys ? "ON" : "OFF"}`);
+  if (pragmas.temp_store) db.pragma(`temp_store = ${pragmas.temp_store}`);
+}
+
+/** BEGIN IMMEDIATE transaction helper. */
+export function withTx<T>(db: SqliteDb, fn: () => T): T {
+  const adapter = createDatabaseAdapter();
+  if (!adapter.isAvailable()) {
+    // No database available, just run the function
+    return fn();
+  }
+
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    const out = fn();
+    db.exec("COMMIT");
+    return out;
+  } catch (e) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+      // ignore
+    }
+    throw e;
+  }
+}
+
+export function ensureSchema(db: SqliteDb, opts?: { allowAutoMigrate?: boolean; failOnDowngrade?: boolean }) {
+  const adapter = createDatabaseAdapter();
+  if (!adapter.isAvailable()) {
+    // Silent skip for mock adapter
+    return;
+  }
+
+  try {
+    db.exec(SCHEMA_SQL);
+
+    const row = db.prepare("SELECT schema_version FROM repo_state WHERE id = 1").get() as { schema_version?: number } | undefined;
+
+    if (!row) {
+      const now = nowISO();
+      db.prepare(
+        "INSERT INTO repo_state (id, schema_version, created_at, updated_at) VALUES (1, ?, ?, ?)"
+      ).run(SCHEMA_VERSION, now, now);
+      // Initialize story key seq
+      db.prepare("INSERT OR IGNORE INTO story_keyseq (id, next_story_num) VALUES (1, 1)").run();
+      return;
+    }
+
+    const currentVersion = row.schema_version ?? 0;
+
+    if (currentVersion === SCHEMA_VERSION) return;
+
+    if (currentVersion > SCHEMA_VERSION && (opts?.failOnDowngrade ?? true)) {
+      throw new Error(
+        `Astrocode DB schema_version ${currentVersion} is newer than this plugin (${SCHEMA_VERSION}). Refusing to downgrade.`
+      );
+    }
+
+    if (currentVersion < SCHEMA_VERSION) {
+      if (!(opts?.allowAutoMigrate ?? true)) {
+        throw new Error(
+          `Astrocode DB schema_version ${currentVersion} is older than required (${SCHEMA_VERSION}). Auto-migrate disabled.`
+        );
+      }
+      // Additive schema: SCHEMA_SQL already created new tables/indexes if missing.
+      db.prepare("UPDATE repo_state SET schema_version = ?, updated_at = ? WHERE id = 1").run(SCHEMA_VERSION, nowISO());
+    }
+  } catch (e) {
+    // Schema operations might fail on mock adapter, silently ignore
+  }
+}

package/src/state/ids.ts

@@ -0,0 +1,33 @@
+import { randomUUID } from "node:crypto";
+
+export function newId(prefix: string): string {
+  return `${prefix}_${randomUUID()}`;
+}
+
+export function newRunId(): string {
+  return newId("run");
+}
+
+export function newStageRunId(): string {
+  return newId("stage");
+}
+
+export function newArtifactId(): string {
+  return newId("art");
+}
+
+export function newToolRunId(): string {
+  return newId("tool");
+}
+
+export function newEventId(): string {
+  return newId("evt");
+}
+
+export function newSnapshotId(): string {
+  return newId("snap");
+}
+
+export function newBatchId(): string {
+  return newId("batch");
+}