@lazyingart/agintiflow 0.1.0

package/src/model-routing.js

@@ -0,0 +1,135 @@
+const COMPLEXITY_KEYWORDS = [
+  "architecture",
+  "refactor",
+  "debug",
+  "failing",
+  "test",
+  "implement",
+  "design",
+  "review",
+  "migrate",
+  "security",
+  "performance",
+  "multi-file",
+  "database",
+  "docker",
+  "ci",
+  "github",
+];
+
+export const ROUTING_MODES = ["smart", "fast", "complex", "manual"];
+
+export function getProviderDefaults(provider = "deepseek") {
+  if (provider === "openai") {
+    return {
+      provider: "openai",
+      apiKey: process.env.LLM_API_KEY || process.env.OPENAI_API_KEY || "",
+      baseURL: process.env.LLM_BASE_URL || "https://api.openai.com/v1",
+      model: process.env.OPENAI_DEFAULT_MODEL || process.env.LLM_MODEL || "gpt-5.4-mini",
+    };
+  }
+
+  return {
+    provider: "deepseek",
+    apiKey: process.env.LLM_API_KEY || process.env.DEEPSEEK_API_KEY || "",
+    baseURL: process.env.LLM_BASE_URL || "https://api.deepseek.com/v1",
+    model: process.env.DEEPSEEK_FAST_MODEL || process.env.LLM_MODEL || "deepseek-v4-flash",
+  };
+}
+
+export function getModelPresets() {
+  return {
+    fast: {
+      id: "fast",
+      label: "Fast base",
+      provider: "deepseek",
+      model: process.env.DEEPSEEK_FAST_MODEL || "deepseek-v4-flash",
+      description: "Default fast route for normal browser, shell, and short coding tasks.",
+    },
+    complex: {
+      id: "complex",
+      label: "Complex reasoning",
+      provider: "deepseek",
+      model: process.env.DEEPSEEK_PRO_MODEL || "deepseek-v4-pro",
+      description: "Higher-capacity DeepSeek route for multi-step coding and design tasks.",
+    },
+    codexPrimary: {
+      id: "codexPrimary",
+      label: "Codex primary wrapper",
+      provider: "codex-wrapper",
+      model: process.env.CODEX_PRIMARY_MODEL || "gpt-5.5",
+      reasoning: process.env.CODEX_PRIMARY_REASONING || "medium",
+      description: "External Codex wrapper route for coding enhancement tasks.",
+    },
+    codexSpare: {
+      id: "codexSpare",
+      label: "Codex spare wrapper",
+      provider: "codex-wrapper",
+      model: process.env.CODEX_SPARE_MODEL || "gpt-5.4-mini",
+      reasoning: process.env.CODEX_SPARE_REASONING || "high",
+      description: "Fallback Codex wrapper route when the primary wrapper fails.",
+    },
+  };
+}
+
+export function scoreTaskComplexity(goal = "") {
+  const text = String(goal).toLowerCase();
+  let score = text.length > 600 ? 2 : text.length > 240 ? 1 : 0;
+  for (const keyword of COMPLEXITY_KEYWORDS) {
+    if (text.includes(keyword)) score += 1;
+  }
+  return score;
+}
+
+export function normalizeRoutingMode(value) {
+  return ROUTING_MODES.includes(value) ? value : "smart";
+}
+
+export function selectModelRoute({ routingMode = "smart", provider = "deepseek", model = "", goal = "" } = {}) {
+  const mode = normalizeRoutingMode(routingMode);
+  const presets = getModelPresets();
+
+  if (mode === "manual") {
+    const defaults = getProviderDefaults(provider);
+    return {
+      routingMode: mode,
+      provider: defaults.provider,
+      model: model || defaults.model,
+      reason: "Manual provider/model selection.",
+      complexityScore: scoreTaskComplexity(goal),
+    };
+  }
+
+  if (mode === "complex") {
+    return {
+      routingMode: mode,
+      provider: presets.complex.provider,
+      model: presets.complex.model,
+      reason: "Complex route selected explicitly.",
+      complexityScore: scoreTaskComplexity(goal),
+    };
+  }
+
+  if (mode === "fast") {
+    return {
+      routingMode: mode,
+      provider: presets.fast.provider,
+      model: presets.fast.model,
+      reason: "Fast route selected explicitly.",
+      complexityScore: scoreTaskComplexity(goal),
+    };
+  }
+
+  const complexityScore = scoreTaskComplexity(goal);
+  const selected = complexityScore >= 3 ? presets.complex : presets.fast;
+  return {
+    routingMode: mode,
+    provider: selected.provider,
+    model: selected.model,
+    reason:
+      selected.id === "complex"
+        ? `Smart routing selected complex route; complexity score ${complexityScore}.`
+        : `Smart routing selected fast route; complexity score ${complexityScore}.`,
+    complexityScore,
+  };
+}

package/src/redaction.js

@@ -0,0 +1,29 @@
+const SECRET_PATTERNS = [
+  /\bsk-[A-Za-z0-9_-]{16,}\b/g,
+  /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g,
+  /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/g,
+  /((?:api[_-]?key|token|secret|password|passwd|npm_token|_authToken)\s*[:=]\s*)[^\s"'`]+/gi,
+  /(\/\/registry\.npmjs\.org\/:_authToken=)[^\s"'`]+/gi,
+  /(Authorization:\s*Bearer\s+)[^\s"'`]+/gi,
+];
+
+export function redactSensitiveText(value) {
+  let text = String(value ?? "");
+  for (const pattern of SECRET_PATTERNS) {
+    text = text.replace(pattern, (...args) => {
+      const captures = args.slice(1, -2).filter((item) => typeof item === "string");
+      const prefix = captures[0] || "";
+      return `${prefix}[REDACTED]`;
+    });
+  }
+  return text;
+}
+
+export function redactValue(value) {
+  if (typeof value === "string") return redactSensitiveText(value);
+  if (Array.isArray(value)) return value.map((item) => redactValue(item));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactValue(item)]));
+  }
+  return value;
+}

package/src/session-store.js

@@ -0,0 +1,73 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export class SessionStore {
+  constructor(baseDir, sessionId) {
+    this.baseDir = baseDir;
+    this.sessionId = sessionId;
+    this.sessionDir = path.join(baseDir, sessionId);
+    this.artifactsDir = path.join(this.sessionDir, "artifacts");
+    this.statePath = path.join(this.sessionDir, "state.json");
+    this.planPath = path.join(this.sessionDir, "plan.md");
+    this.eventsPath = path.join(this.sessionDir, "events.jsonl");
+    this.storageStatePath = path.join(this.sessionDir, "storage-state.json");
+  }
+
+  async ensure() {
+    await fs.mkdir(this.artifactsDir, { recursive: true });
+  }
+
+  async loadState() {
+    try {
+      const raw = await fs.readFile(this.statePath, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+
+  async saveState(state) {
+    await this.ensure();
+    await fs.writeFile(this.statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+  }
+
+  async savePlan(planText) {
+    await this.ensure();
+    await fs.writeFile(this.planPath, `${planText.trim()}\n`, "utf8");
+  }
+
+  async appendEvent(type, data = {}) {
+    await this.ensure();
+    const line = JSON.stringify({
+      timestamp: new Date().toISOString(),
+      type,
+      data,
+    });
+    await fs.appendFile(this.eventsPath, `${line}\n`, "utf8");
+  }
+
+  async loadEvents() {
+    try {
+      const raw = await fs.readFile(this.eventsPath, "utf8");
+      return raw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+    } catch {
+      return [];
+    }
+  }
+
+  async saveSnapshot(step, snapshot) {
+    await this.ensure();
+    const filename = `step-${String(step).padStart(3, "0")}.snapshot.json`;
+    const filePath = path.join(this.artifactsDir, filename);
+    await fs.writeFile(filePath, `${JSON.stringify(snapshot, null, 2)}\n`, "utf8");
+    return filePath;
+  }
+
+  screenshotPath(step) {
+    return path.join(this.artifactsDir, `step-${String(step).padStart(3, "0")}.png`);
+  }
+}

package/src/snapshot.js

@@ -0,0 +1,55 @@
+export async function captureSnapshot(page, store, step) {
+  const snapshot = await page.evaluate(() => {
+    const isVisible = (el) => {
+      const rect = el.getBoundingClientRect();
+      const style = window.getComputedStyle(el);
+      return rect.width > 0 && rect.height > 0 && style.display !== "none" && style.visibility !== "hidden";
+    };
+
+    document.querySelectorAll("[data-agent-id]").forEach((el) => el.removeAttribute("data-agent-id"));
+
+    const candidates = Array.from(
+      document.querySelectorAll("a, button, input, textarea, select, [role='button'], [contenteditable='true']")
+    );
+
+    const elements = [];
+
+    for (const el of candidates) {
+      if (!isVisible(el)) continue;
+      if (elements.length >= 50) break;
+
+      const id = String(elements.length + 1);
+      el.setAttribute("data-agent-id", id);
+
+      const tag = el.tagName.toLowerCase();
+      elements.push({
+        id,
+        tag,
+        role: el.getAttribute("role") || "",
+        text: (el.innerText || el.textContent || "").replace(/\s+/g, " ").trim().slice(0, 100),
+        ariaLabel: (el.getAttribute("aria-label") || "").trim().slice(0, 100),
+        placeholder: (el.getAttribute("placeholder") || "").trim().slice(0, 100),
+        href: tag === "a" ? (el.getAttribute("href") || "").trim() : "",
+        inputType: tag === "input" ? (el.getAttribute("type") || "text").trim() : "",
+        autocomplete: (el.getAttribute("autocomplete") || "").trim(),
+      });
+    }
+
+    return {
+      title: document.title,
+      url: window.location.href,
+      pageText: (document.body?.innerText || "").replace(/\s+/g, " ").trim().slice(0, 2500),
+      elements,
+    };
+  });
+
+  const screenshotPath = store.screenshotPath(step);
+  await page.screenshot({ path: screenshotPath, fullPage: true });
+  const snapshotPath = await store.saveSnapshot(step, snapshot);
+
+  return {
+    ...snapshot,
+    screenshotPath,
+    snapshotPath,
+  };
+}

package/src/tool-wrappers.js

@@ -0,0 +1,193 @@
+import { execFile as execFileCallback, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+import { getModelPresets } from "./model-routing.js";
+import { redactSensitiveText } from "./redaction.js";
+
+const execFile = promisify(execFileCallback);
+
+export const WRAPPER_NAMES = ["codex", "claude", "gemini", "copilot", "qwen"];
+
+const BASE_ADVISORY_PROMPT = [
+  "You are being called as an advisory wrapper tool inside AgInTiFlow.",
+  "Do not modify files, run destructive commands, push commits, install packages, or use secrets.",
+  "Return concise findings, commands to consider, or an implementation plan.",
+].join(" ");
+
+function commandExists(command) {
+  try {
+    execFileSync("bash", ["-lc", `command -v ${command}`], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function cleanOutput(value, limit) {
+  return redactSensitiveText(value).trim().slice(0, limit);
+}
+
+function buildPrompt(prompt) {
+  return `${BASE_ADVISORY_PROMPT}\n\nTask:\n${prompt}`;
+}
+
+function codexArgs(prompt, config, preset) {
+  return [
+    "exec",
+    "--model",
+    preset.model,
+    "-c",
+    `model_reasoning_effort="${preset.reasoning}"`,
+    "--sandbox",
+    "read-only",
+    "--cd",
+    config.commandCwd,
+    "--skip-git-repo-check",
+    buildPrompt(prompt),
+  ];
+}
+
+function wrapperCommand(wrapper, prompt, config, { fallback = false } = {}) {
+  const presets = getModelPresets();
+  switch (wrapper) {
+    case "codex":
+      return {
+        command: "codex",
+        args: codexArgs(prompt, config, fallback ? presets.codexSpare : presets.codexPrimary),
+      };
+    case "claude":
+      return {
+        command: "claude",
+        args: [
+          "--print",
+          "--permission-mode",
+          "plan",
+          "--output-format",
+          "text",
+          "--model",
+          process.env.CLAUDE_WRAPPER_MODEL || "sonnet",
+          buildPrompt(prompt),
+        ],
+      };
+    case "gemini":
+      return {
+        command: "gemini",
+        args: ["--prompt", buildPrompt(prompt)],
+      };
+    case "copilot":
+      return {
+        command: "gh",
+        args: ["copilot", "-p", buildPrompt(prompt)],
+      };
+    case "qwen":
+      return {
+        command: "qwen",
+        args: ["--approval-mode", "plan", "--output-format", "text", buildPrompt(prompt)],
+      };
+    default:
+      return null;
+  }
+}
+
+export function isKnownWrapper(wrapper) {
+  return WRAPPER_NAMES.includes(wrapper);
+}
+
+export function listAgentWrappers() {
+  const presets = getModelPresets();
+  return [
+    {
+      name: "codex",
+      label: "Codex",
+      available: commandExists("codex"),
+      role: `Coding enhancement wrapper; primary ${presets.codexPrimary.model} ${presets.codexPrimary.reasoning}, spare ${presets.codexSpare.model} ${presets.codexSpare.reasoning}.`,
+    },
+    {
+      name: "claude",
+      label: "Claude Code",
+      available: commandExists("claude"),
+      role: "Planning and codebase reasoning wrapper in plan mode.",
+    },
+    {
+      name: "gemini",
+      label: "Gemini CLI",
+      available: commandExists("gemini"),
+      role: "General research and large-context CLI wrapper when installed.",
+    },
+    {
+      name: "copilot",
+      label: "GitHub Copilot CLI",
+      available: commandExists("gh"),
+      role: "GitHub/Copilot CLI wrapper when authenticated.",
+    },
+    {
+      name: "qwen",
+      label: "Qwen Code",
+      available: commandExists("qwen"),
+      role: "Chinese/open provider coding wrapper in plan approval mode.",
+    },
+  ];
+}
+
+export function wrapperStatusText() {
+  return listAgentWrappers()
+    .map((wrapper) => `${wrapper.name}:${wrapper.available ? "available" : "missing"}`)
+    .join(", ");
+}
+
+export async function runAgentWrapper({ wrapper, prompt }, config) {
+  if (!isKnownWrapper(wrapper)) {
+    return { ok: false, wrapper, error: `Unknown wrapper: ${wrapper}` };
+  }
+
+  const commandSpec = wrapperCommand(wrapper, prompt, config);
+  if (!commandSpec || !commandExists(commandSpec.command)) {
+    return { ok: false, wrapper, error: `Wrapper command is not available: ${wrapper}` };
+  }
+
+  const runOnce = async (spec) =>
+    execFile(spec.command, spec.args, {
+      cwd: config.commandCwd,
+      timeout: Number(config.wrapperTimeoutMs) || 120000,
+      maxBuffer: 512 * 1024,
+      env: process.env,
+    });
+
+  try {
+    const result = await runOnce(commandSpec);
+    return {
+      ok: true,
+      wrapper,
+      stdout: cleanOutput(result.stdout, 12000),
+      stderr: cleanOutput(result.stderr, 4000),
+    };
+  } catch (error) {
+    if (wrapper === "codex") {
+      const fallbackSpec = wrapperCommand(wrapper, prompt, config, { fallback: true });
+      try {
+        const fallback = await runOnce(fallbackSpec);
+        return {
+          ok: true,
+          wrapper,
+          fallback: true,
+          stdout: cleanOutput(fallback.stdout, 12000),
+          stderr: cleanOutput(fallback.stderr, 4000),
+        };
+      } catch (fallbackError) {
+        return {
+          ok: false,
+          wrapper,
+          error: redactSensitiveText(fallbackError instanceof Error ? fallbackError.message : String(fallbackError)),
+          primaryError: redactSensitiveText(error instanceof Error ? error.message : String(error)),
+        };
+      }
+    }
+
+    return {
+      ok: false,
+      wrapper,
+      error: redactSensitiveText(error instanceof Error ? error.message : String(error)),
+      stdout: cleanOutput(error.stdout, 8000),
+      stderr: cleanOutput(error.stderr, 4000),
+    };
+  }
+}

package/src/web-db.js

@@ -0,0 +1,158 @@
+import fs from "node:fs";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { getModelPresets } from "./model-routing.js";
+
+function defaultPreferences(baseDir) {
+  const presets = getModelPresets();
+  return {
+    routingMode: "smart",
+    provider: "deepseek",
+    model: presets.fast.model,
+    headless: true,
+    maxSteps: 15,
+    startUrl: "",
+    allowedDomains: "",
+    commandCwd: path.resolve(baseDir, ".."),
+    allowShellTool: true,
+    allowWrapperTools: false,
+    wrapperTimeoutMs: 120000,
+    sandboxMode: "docker-readonly",
+    packageInstallPolicy: "prompt",
+    useDockerSandbox: true,
+    dockerSandboxImage: "agintiflow-sandbox:latest",
+    allowPasswords: false,
+    allowDestructive: false,
+    language: "en",
+  };
+}
+
+export class WebDatabase {
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+    this.dbDir = path.join(baseDir, ".sessions");
+    this.dbPath = path.join(this.dbDir, "web-state.sqlite");
+    fs.mkdirSync(this.dbDir, { recursive: true });
+    this.db = new DatabaseSync(this.dbPath);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS preferences (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        session_id TEXT PRIMARY KEY,
+        provider TEXT NOT NULL,
+        model TEXT NOT NULL,
+        goal TEXT NOT NULL,
+        status TEXT NOT NULL,
+        started_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        ended_at TEXT,
+        result TEXT,
+        error TEXT
+      );
+    `);
+  }
+
+  getPreferences() {
+    const row = this.db.prepare("SELECT value FROM preferences WHERE key = ?").get("ui");
+    if (!row) return defaultPreferences(this.baseDir);
+
+    try {
+      return {
+        ...defaultPreferences(this.baseDir),
+        ...JSON.parse(row.value),
+      };
+    } catch {
+      return defaultPreferences(this.baseDir);
+    }
+  }
+
+  savePreferences(preferences) {
+    const value = JSON.stringify(preferences);
+    const updatedAt = new Date().toISOString();
+    this.db
+      .prepare(
+        `INSERT INTO preferences (key, value, updated_at)
+         VALUES (?, ?, ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
+      )
+      .run("ui", value, updatedAt);
+  }
+
+  upsertSession(session) {
+    const updatedAt = session.updatedAt || new Date().toISOString();
+    this.db
+      .prepare(
+        `INSERT INTO sessions (
+          session_id, provider, model, goal, status, started_at, updated_at, ended_at, result, error
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(session_id) DO UPDATE SET
+          provider = excluded.provider,
+          model = excluded.model,
+          goal = excluded.goal,
+          status = excluded.status,
+          updated_at = excluded.updated_at,
+          ended_at = excluded.ended_at,
+          result = excluded.result,
+          error = excluded.error`
+      )
+      .run(
+        session.sessionId,
+        session.provider,
+        session.model,
+        session.goal,
+        session.status,
+        session.startedAt,
+        updatedAt,
+        session.endedAt || null,
+        session.result || "",
+        session.error || ""
+      );
+  }
+
+  getSession(sessionId) {
+    return (
+      this.db
+        .prepare(
+          `SELECT
+             session_id AS sessionId,
+             provider,
+             model,
+             goal,
+             status,
+             started_at AS startedAt,
+             updated_at AS updatedAt,
+             ended_at AS endedAt,
+             result,
+             error
+           FROM sessions
+           WHERE session_id = ?`
+        )
+        .get(sessionId) || null
+    );
+  }
+
+  listSessions(limit = 20) {
+    return this.db
+      .prepare(
+        `SELECT
+           session_id AS sessionId,
+           provider,
+           model,
+           goal,
+           status,
+           started_at AS startedAt,
+           updated_at AS updatedAt,
+           ended_at AS endedAt,
+           result,
+           error
+         FROM sessions
+         ORDER BY updated_at DESC
+         LIMIT ?`
+      )
+      .all(limit);
+  }
+}