@oisheek_c/codeforge 1.0.1

package/packages/terminal/activity.js

@@ -0,0 +1,514 @@
+/**
+ * packages/terminal/activity.js
+ *
+ * Mutable presentation state for the live
+ * CodeForge terminal dashboard.
+ *
+ * The agent/executor owns execution.
+ * This module only translates execution events
+ * into UI state.
+ */
+
+const STAGE_LABELS = Object.freeze({
+  intent: {
+    active: "Understanding request",
+    complete: "Understood request",
+  },
+
+  plan: {
+    active: "Planning approach",
+    complete: "Planned approach",
+  },
+
+  retrieve: {
+    active: "Searching repository",
+    complete: "Searched repository",
+  },
+
+  context: {
+    active: "Building context",
+    complete: "Built context",
+  },
+
+  route: {
+    active: "Selecting model",
+    complete: "Selected model",
+  },
+
+  thinking: {
+    active: "Preparing reasoning",
+    complete: "Reasoning configured",
+  },
+
+  generate: {
+    active: "Thinking",
+    complete: "Generated response",
+  },
+
+  tool_round: {
+    active: "Using tools",
+    complete: "Completed tool round",
+  },
+
+  tool: {
+    active: "Running tool",
+    complete: "Completed tool",
+  },
+
+  approval: {
+    active: "Waiting for approval",
+    complete: "Approval resolved",
+  },
+
+  fallback: {
+    active: "Selecting fallback",
+    complete: "Switched model",
+  },
+
+  complete: {
+    active: "Finishing",
+    complete: "Completed",
+  },
+});
+
+function createUsage() {
+  return {
+    promptTokens: 0,
+    completionTokens: 0,
+    reasoningTokens: 0,
+    totalTokens: 0,
+    cost: null,
+  };
+}
+
+export function createActivityState({
+  projectRoot = null,
+} = {}) {
+  return {
+    projectRoot,
+
+    running: false,
+    completed: false,
+    failed: false,
+
+    startedAt: null,
+    completedAt: null,
+
+    activeStage: null,
+    activeLabel: "",
+    activeDetail: "",
+    activeStartedAt: null,
+
+    completedStages: [],
+
+    retrievedFiles: [],
+    retrievedResults: [],
+
+    contextMetrics: [],
+
+    provider: null,
+    modelRole: null,
+    model: null,
+
+    attempt: null,
+    maxAttempts: null,
+    attempts: null,
+
+    finishReason: null,
+
+    usage: createUsage(),
+
+    lastError: null,
+  };
+}
+
+export function resetActivityState(
+  state
+) {
+  const fresh =
+    createActivityState({
+      projectRoot:
+        state.projectRoot,
+    });
+
+  Object.assign(
+    state,
+    fresh
+  );
+
+  state.running = true;
+  state.startedAt =
+    Date.now();
+
+  return state;
+}
+
+function getStageLabel(
+  stage,
+  mode
+) {
+  return (
+    STAGE_LABELS[stage]?.[mode] ??
+    stage ??
+    "Working"
+  );
+}
+
+function updateTelemetry(
+  state,
+  event
+) {
+  const data =
+    event?.data;
+
+  if (!data) {
+    return;
+  }
+
+  if (
+    event.type ===
+    "context:metrics"
+  ) {
+    /*
+     * A fallback may measure the same model
+     * context again before another provider
+     * attempt.
+     *
+     * Preserve genuinely different tool rounds,
+     * but avoid visually duplicating an identical
+     * context measurement.
+     */
+    const metric = {
+      toolRound:
+        data.toolRound ?? 0,
+
+      messages:
+        data.messages ?? 0,
+
+      chars:
+        data.chars ?? {},
+
+      estimatedTokens:
+        data.estimatedTokens ?? {},
+    };
+
+    const previous =
+      state.contextMetrics[
+        state.contextMetrics.length - 1
+      ];
+
+    const duplicate =
+      previous &&
+      previous.toolRound ===
+        metric.toolRound &&
+      previous.messages ===
+        metric.messages &&
+      previous.estimatedTokens?.total ===
+        metric.estimatedTokens?.total;
+
+    if (!duplicate) {
+      state.contextMetrics.push(
+        metric
+      );
+    }
+
+    return;
+  }
+
+  if (
+    event.stage ===
+    "retrieve"
+  ) {
+    if (
+      Array.isArray(
+        data.files
+      )
+    ) {
+      state.retrievedFiles = [
+        ...data.files,
+      ];
+    }
+
+    if (
+      Array.isArray(
+        data.results
+      )
+    ) {
+      state.retrievedResults =
+        data.results.map(
+          (result) => ({
+            path:
+              result?.path ?? "",
+
+            score:
+              Number.isFinite(
+                result?.score
+              )
+                ? result.score
+                : null,
+
+            reason:
+              result?.reason ??
+              null,
+          })
+        );
+    }
+  }
+
+  if (data.provider) {
+    state.provider =
+      data.provider;
+  }
+
+  if (data.modelRole) {
+    state.modelRole =
+      data.modelRole;
+  }
+
+  if (data.model) {
+    state.model =
+      data.model;
+  }
+
+  if (
+    Number.isFinite(
+      data.attempt
+    )
+  ) {
+    state.attempt =
+      data.attempt;
+  }
+
+  if (
+    Number.isFinite(
+      data.maxAttempts
+    )
+  ) {
+    state.maxAttempts =
+      data.maxAttempts;
+  }
+
+  if (
+    Number.isFinite(
+      data.attempts
+    )
+  ) {
+    state.attempts =
+      data.attempts;
+  }
+
+  if (data.finishReason) {
+    state.finishReason =
+      data.finishReason;
+  }
+
+  if (data.usage) {
+    state.usage = {
+      ...state.usage,
+      ...data.usage,
+    };
+  }
+}
+
+function completeStage(
+  state,
+  event,
+  status
+) {
+  const stage =
+    event.stage;
+
+  const now =
+    Date.now();
+
+  let durationMs =
+    Number.isFinite(
+      event.durationMs
+    )
+      ? event.durationMs
+      : null;
+
+  if (
+    state.activeStage ===
+      stage &&
+    Number.isFinite(
+      state.activeStartedAt
+    )
+  ) {
+    durationMs =
+      now -
+      state.activeStartedAt;
+  }
+
+  const existingIndex =
+    state.completedStages.findIndex(
+      (item) =>
+        item.stage === stage
+    );
+
+  const item = {
+    stage,
+    status,
+
+    label:
+      getStageLabel(
+        stage,
+        "complete"
+      ),
+
+    detail:
+      event.detail ?? "",
+
+    durationMs,
+  };
+
+  if (
+    existingIndex >= 0
+  ) {
+    state.completedStages[
+      existingIndex
+    ] = item;
+  } else {
+    state.completedStages.push(
+      item
+    );
+  }
+
+  if (
+    state.activeStage ===
+    stage
+  ) {
+    state.activeStage =
+      null;
+
+    state.activeLabel =
+      "";
+
+    state.activeDetail =
+      "";
+
+    state.activeStartedAt =
+      null;
+  }
+}
+
+export function applyActivityEvent(
+  state,
+  event = {}
+) {
+  if (
+    event.type ===
+    "run:start"
+  ) {
+    resetActivityState(
+      state
+    );
+
+    return state;
+  }
+
+  updateTelemetry(
+    state,
+    event
+  );
+
+  if (
+    event.type ===
+    "context:metrics"
+  ) {
+    return state;
+  }
+
+  if (
+    event.type ===
+    "stage:start"
+  ) {
+    state.activeStage =
+      event.stage;
+
+    state.activeLabel =
+      getStageLabel(
+        event.stage,
+        "active"
+      );
+
+    state.activeDetail =
+      event.detail ?? "";
+
+    state.activeStartedAt =
+      Date.now();
+
+    return state;
+  }
+
+  if (
+    event.type ===
+    "stage:success"
+  ) {
+    completeStage(
+      state,
+      event,
+      "success"
+    );
+
+    if (
+      event.stage ===
+      "complete"
+    ) {
+      state.running =
+        false;
+
+      state.completed =
+        true;
+
+      state.completedAt =
+        Date.now();
+    }
+
+    return state;
+  }
+
+  if (
+    event.type ===
+    "stage:error"
+  ) {
+    completeStage(
+      state,
+      event,
+      "error"
+    );
+
+    state.lastError =
+      event.detail ??
+      "Execution failed";
+
+    if (
+      event.stage ===
+      "complete"
+    ) {
+      state.running =
+        false;
+
+      state.failed =
+        true;
+
+      state.completedAt =
+        Date.now();
+    }
+
+    return state;
+  }
+
+  if (
+    event.type ===
+    "stage:skipped"
+  ) {
+    completeStage(
+      state,
+      event,
+      "skipped"
+    );
+  }
+
+  return state;
+}

package/packages/terminal/banner.js

@@ -0,0 +1,34 @@
+import { readFileSync } from "node:fs";
+import { colors } from "./colors.js";
+
+const packageJson = JSON.parse(
+  readFileSync(new URL("../../package.json", import.meta.url), "utf8")
+);
+
+const VERSION = packageJson.version;
+
+export function showBanner() {
+  console.clear();
+
+  const logo = `
+ ██████╗ ██████╗ ██████╗ ███████╗███████╗ ██████╗ ██████╗  ██████╗ ███████╗
+██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██╔════╝
+██║     ██║   ██║██║  ██║█████╗  █████╗  ██║   ██║██████╔╝██║  ███╗█████╗
+██║     ██║   ██║██║  ██║██╔══╝  ██╔══╝  ██║   ██║██╔══██╗██║   ██║██╔══╝
+╚██████╗╚██████╔╝██████╔╝███████╗██║     ╚██████╔╝██║  ██║╚██████╔╝███████╗
+ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝      ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝
+`;
+
+  console.log(colors.primary(logo));
+
+console.log(colors.bold(colors.text(`CodeForge AI v${VERSION}`)));
+console.log(colors.muted("Terminal-Native AI Software Engineering Agent"));
+
+  console.log(
+    colors.primary(
+      "────────────────────────────────────────────────────────────"
+    )
+  );
+
+  console.log();
+}

package/packages/terminal/colors.js

@@ -0,0 +1,16 @@
+import chalk from "chalk";
+
+export const colors = {
+  primary: chalk.cyanBright,
+  secondary: chalk.blueBright,
+
+  success: chalk.greenBright,
+  warning: chalk.yellowBright,
+  error: chalk.redBright,
+  info: chalk.blue,
+
+  text: chalk.white,
+  muted: chalk.gray,
+
+  bold: chalk.bold,
+};

package/packages/terminal/dashboard.js

@@ -0,0 +1,94 @@
+/**
+ * packages/terminal/dashboard.js
+ *
+ * Coordinates agent activity events with
+ * the live terminal renderer.
+ *
+ * Execution remains owned by packages/agent.
+ * Presentation remains owned by packages/terminal.
+ */
+
+import {
+  applyActivityEvent,
+  createActivityState,
+} from "./activity.js";
+
+import {
+  createLiveRenderer,
+} from "./renderer.js";
+
+export function createAgentDashboard({
+  enabled = true,
+  projectRoot = null,
+} = {}) {
+  const interactive =
+    Boolean(
+      enabled &&
+      process.stdout.isTTY
+    );
+
+  const state =
+    createActivityState({
+      projectRoot,
+    });
+
+  const renderer =
+    createLiveRenderer({
+      enabled:
+        interactive,
+    });
+
+  function handle(
+    event = {}
+  ) {
+    if (!interactive) {
+      return;
+    }
+
+    applyActivityEvent(
+      state,
+      event
+    );
+
+    renderer.setState(
+      state
+    );
+  }
+
+  function suspend() {
+    renderer.suspend();
+  }
+
+  function resume() {
+    renderer.resume();
+  }
+
+  function finish() {
+    if (!interactive) {
+      return;
+    }
+
+    renderer.setState(
+      state
+    );
+
+    renderer.finish();
+  }
+
+  function dispose() {
+    renderer.dispose();
+  }
+
+  return {
+    enabled:
+      interactive,
+
+    handle,
+
+    suspend,
+    resume,
+
+    finish,
+    dispose,
+  };
+}

package/packages/terminal/index.js

@@ -0,0 +1,19 @@
+export * from "./banner.js";
+export * from "./colors.js";
+export * from "./logger.js";
+export * from "./prompt.js";
+export * from "./spinner.js";
+
+export {
+  createActivityState,
+  resetActivityState,
+  applyActivityEvent,
+} from "./activity.js";
+
+export {
+  createLiveRenderer,
+} from "./renderer.js";
+
+export {
+  createAgentDashboard,
+} from "./dashboard.js";

package/packages/terminal/logger.js

@@ -0,0 +1,43 @@
+import { colors } from "./colors.js";
+
+function print(symbol, color, message = "") {
+  console.log(
+    color(`${symbol} ${String(message)}`)
+  );
+}
+
+export const logger = {
+  info(message) {
+    print("ℹ", colors.info, message);
+  },
+
+  success(message) {
+    print("✔", colors.success, message);
+  },
+
+  warn(message) {
+    print("⚠", colors.warning, message);
+  },
+
+  error(message) {
+    print("✖", colors.error, message);
+  },
+
+  debug(message) {
+    if (process.env.DEBUG === "true") {
+      print("•", colors.secondary, message);
+    }
+  },
+
+  plain(message) {
+    console.log(colors.text(message));
+  },
+
+  line() {
+    console.log(
+      colors.muted(
+        "────────────────────────────────────────────────────────────────"
+      )
+    );
+  },
+};

package/packages/terminal/prompt.js

@@ -0,0 +1,11 @@
+import readline from "node:readline";
+
+export function createPrompt() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: "> ",
+    historySize: 1000,
+    terminal: true,
+  });
+}