stagent 0.1.0

package/dist/cli.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+
+// bin/cli.ts
+import { program } from "commander";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+import {
+  mkdirSync,
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  cpSync,
+  unlinkSync
+} from "fs";
+import { spawn } from "child_process";
+import { createServer } from "net";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+
+// src/lib/utils/stagent-paths.ts
+import { homedir } from "os";
+import { join } from "path";
+function getStagentDataDir() {
+  return process.env.STAGENT_DATA_DIR || join(homedir(), ".stagent");
+}
+function getStagentDbPath() {
+  return join(getStagentDataDir(), "stagent.db");
+}
+
+// bin/cli.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var appDir = join2(__dirname, "..");
+var DATA_DIR = getStagentDataDir();
+var dbPath = getStagentDbPath();
+var pkg = JSON.parse(readFileSync(join2(appDir, "package.json"), "utf-8"));
+var HELP_TEXT = `
+Data:
+  Directory        ${DATA_DIR}
+  Database         ${dbPath}
+  Sessions         ${join2(DATA_DIR, "sessions")}
+  Logs             ${join2(DATA_DIR, "logs")}
+
+Environment variables:
+  STAGENT_DATA_DIR Custom data directory for the CLI and web app
+  ANTHROPIC_API_KEY Claude runtime access
+  OPENAI_API_KEY   OpenAI Codex runtime access
+
+Examples:
+  npx stagent
+  npx stagent --port 3210 --no-open
+  STAGENT_DATA_DIR=/tmp/stagent-smoke npx stagent --reset
+`;
+program.name("stagent").description("Governed AI agent workspace \u2014 local-first").version(pkg.version).addHelpText("after", HELP_TEXT).option("-p, --port <number>", "port to start on", "3000").option("--reset", "delete the local database before starting").option("--no-open", "don't auto-open browser").parse();
+var opts = program.opts();
+var requestedPort = Number.parseInt(opts.port, 10);
+if (Number.isNaN(requestedPort) || requestedPort <= 0) {
+  program.error(`Invalid port: ${opts.port}`);
+}
+for (const dir of [DATA_DIR, join2(DATA_DIR, "logs"), join2(DATA_DIR, "sessions")]) {
+  mkdirSync(dir, { recursive: true });
+}
+if (opts.reset) {
+  if (existsSync(dbPath)) {
+    unlinkSync(dbPath);
+    for (const suffix of ["-wal", "-shm"]) {
+      const filePath = dbPath + suffix;
+      if (existsSync(filePath)) unlinkSync(filePath);
+    }
+    console.log("Database reset.");
+  } else {
+    console.log("No database found to reset.");
+  }
+}
+var sqlite = new Database(dbPath);
+sqlite.pragma("journal_mode = WAL");
+sqlite.pragma("foreign_keys = ON");
+var db = drizzle(sqlite);
+var migrationsDir = join2(appDir, "src", "lib", "db", "migrations");
+migrate(db, { migrationsFolder: migrationsDir });
+sqlite.close();
+console.log("Database ready.");
+function findAvailablePort(preferred) {
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.listen(preferred, () => {
+      server.close(() => resolve(preferred));
+    });
+    server.on("error", () => {
+      resolve(findAvailablePort(preferred + 1));
+    });
+  });
+}
+function findLocalBin(name, cwd) {
+  const local = join2(cwd, "node_modules", ".bin", name);
+  if (existsSync(local)) return local;
+  let dir = dirname(cwd);
+  while (dir !== dirname(dir)) {
+    const candidate = join2(dir, "node_modules", ".bin", name);
+    if (existsSync(candidate)) return candidate;
+    dir = dirname(dir);
+  }
+  return name;
+}
+async function main() {
+  const actualPort = await findAvailablePort(requestedPort);
+  let effectiveCwd = appDir;
+  const localNm = join2(appDir, "node_modules");
+  if (!existsSync(join2(localNm, "next", "package.json"))) {
+    let searchDir = dirname(appDir);
+    while (searchDir !== dirname(searchDir)) {
+      const candidate = join2(searchDir, "node_modules", "next", "package.json");
+      if (existsSync(candidate)) {
+        const hoistedRoot = searchDir;
+        for (const name of ["src", "public"]) {
+          const dest = join2(hoistedRoot, name);
+          const src = join2(appDir, name);
+          if (!existsSync(dest) && existsSync(src)) {
+            cpSync(src, dest, { recursive: true });
+          }
+        }
+        for (const name of [
+          "next.config.mjs",
+          "tsconfig.json",
+          "postcss.config.mjs",
+          "package.json",
+          "components.json",
+          "drizzle.config.ts"
+        ]) {
+          const dest = join2(hoistedRoot, name);
+          const src = join2(appDir, name);
+          if (!existsSync(dest) && existsSync(src)) {
+            writeFileSync(dest, readFileSync(src));
+          }
+        }
+        effectiveCwd = hoistedRoot;
+        break;
+      }
+      searchDir = dirname(searchDir);
+    }
+  }
+  const nextBin = findLocalBin("next", effectiveCwd);
+  console.log(`Stagent ${pkg.version}`);
+  console.log(`Data dir: ${DATA_DIR}`);
+  console.log(`Starting Stagent on http://localhost:${actualPort}`);
+  const child = spawn(nextBin, ["dev", "--turbopack", "--port", String(actualPort)], {
+    cwd: effectiveCwd,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      STAGENT_DATA_DIR: DATA_DIR,
+      PORT: String(actualPort)
+    }
+  });
+  if (opts.open !== false) {
+    setTimeout(async () => {
+      try {
+        const open = (await import("open")).default;
+        await open(`http://localhost:${actualPort}`);
+      } catch {
+      }
+    }, 3e3);
+  }
+  process.on("SIGINT", () => child.kill("SIGINT"));
+  process.on("SIGTERM", () => child.kill("SIGTERM"));
+  child.on("exit", (code) => process.exit(code ?? 0));
+}
+main().catch((err) => {
+  console.error("Failed to start Stagent:", err);
+  process.exit(1);
+});

package/drizzle.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "drizzle-kit";
+import { homedir } from "os";
+import { join } from "path";
+
+export default defineConfig({
+  schema: "./src/lib/db/schema.ts",
+  out: "./src/lib/db/migrations",
+  dialect: "sqlite",
+  dbCredentials: {
+    url: join(homedir(), ".stagent", "stagent.db"),
+  },
+});

package/next.config.mjs

@@ -0,0 +1,15 @@
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  serverExternalPackages: ["better-sqlite3"],
+  devIndicators: false,
+  turbopack: {
+    root: __dirname,
+  },
+};
+
+export default nextConfig;

package/package.json

@@ -0,0 +1,114 @@
+{
+  "name": "stagent",
+  "version": "0.1.0",
+  "description": "Governed AI agent workspace for supervised local execution, workflows, documents, and provider runtimes.",
+  "keywords": [
+    "ai",
+    "agents",
+    "automation",
+    "workflow",
+    "claude",
+    "openai",
+    "codex",
+    "nextjs",
+    "local-first"
+  ],
+  "license": "Apache-2.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/navam-io/stagent.git"
+  },
+  "bugs": {
+    "url": "https://github.com/navam-io/stagent/issues"
+  },
+  "homepage": "https://github.com/navam-io/stagent#readme",
+  "bin": {
+    "stagent": "./dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "src/",
+    "!src/**/__tests__/",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/**/*.spec.ts",
+    "!src/**/*.spec.tsx",
+    "!src/test/",
+    "public/",
+    "next.config.mjs",
+    "tsconfig.json",
+    "drizzle.config.ts",
+    "postcss.config.mjs",
+    "components.json",
+    "package.json"
+  ],
+  "scripts": {
+    "dev": "next dev --turbopack",
+    "build": "next build",
+    "build:cli": "tsup",
+    "prepublishOnly": "npm run build:cli",
+    "smoke:npm": "node scripts/smoke-npm-package.mjs",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:ui": "vitest --ui"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.71",
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
+    "@hookform/resolvers": "^5.2.2",
+    "@tailwindcss/typography": "^0.5",
+    "better-sqlite3": "^12",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2",
+    "cmdk": "^1.1.1",
+    "commander": "^14",
+    "cron-parser": "^5.5.0",
+    "drizzle-orm": "^0.45",
+    "image-size": "^2.0.2",
+    "js-yaml": "^4.1.1",
+    "jszip": "^3.10.1",
+    "lucide-react": "^0.474.0",
+    "mammoth": "^1.11.0",
+    "next": "^16",
+    "next-themes": "^0.4.6",
+    "open": "^10",
+    "pdf-parse": "^2.4.5",
+    "radix-ui": "^1.4.3",
+    "react": "^19",
+    "react-dom": "^19",
+    "react-hook-form": "^7.71.2",
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1",
+    "sonner": "^2.0.7",
+    "tailwind-merge": "^3",
+    "tw-animate-css": "^1",
+    "xlsx": "^0.18.5",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/better-sqlite3": "^7",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "@vitejs/plugin-react": "^5.1.4",
+    "@vitest/coverage-v8": "^4.0.18",
+    "drizzle-kit": "^0.30",
+    "jsdom": "^28.1.0",
+    "tailwindcss": "^4",
+    "tsup": "^8.5",
+    "typescript": "^5",
+    "vitest": "^4.0.18"
+  }
+}

package/postcss.config.mjs

@@ -0,0 +1,8 @@
+/** @type {import('postcss-load-config').Config} */
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;

package/public/icon.svg

@@ -0,0 +1,13 @@
+<svg width="512" height="512" viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <rect width="512" height="512" rx="112" fill="#0f172a"/>
+  <defs>
+    <linearGradient id="s-grad" x1="150" y1="80" x2="362" y2="432" gradientUnits="userSpaceOnUse">
+      <stop offset="0%" stop-color="#22d3ee"/>
+      <stop offset="50%" stop-color="#3b82f6"/>
+      <stop offset="100%" stop-color="#2563eb"/>
+    </linearGradient>
+  </defs>
+  <path d="M340 130c0 0-60-10-110 30s-50 90-10 115c40 25 70 30 70 30s50 15 30 65c-20 50-80 40-80 40" stroke="url(#s-grad)" stroke-width="56" stroke-linecap="round" fill="none"/>
+  <circle cx="340" cy="130" r="36" fill="#22d3ee"/>
+  <circle cx="240" cy="410" r="36" fill="#2563eb"/>
+</svg>

package/src/app/api/blueprints/[id]/instantiate/route.ts

@@ -0,0 +1,27 @@
+import { NextRequest, NextResponse } from "next/server";
+import { instantiateBlueprint } from "@/lib/workflows/blueprints/instantiator";
+
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    const { variables, projectId } = await req.json();
+
+    if (!variables || typeof variables !== "object") {
+      return NextResponse.json(
+        { error: "variables object is required" },
+        { status: 400 }
+      );
+    }
+
+    const result = await instantiateBlueprint(id, variables, projectId);
+    return NextResponse.json(result, { status: 201 });
+  } catch (err: unknown) {
+    const message =
+      err instanceof Error ? err.message : "Failed to instantiate blueprint";
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/src/app/api/blueprints/[id]/route.ts

@@ -0,0 +1,39 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  getBlueprint,
+  deleteBlueprint,
+} from "@/lib/workflows/blueprints/registry";
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const blueprint = getBlueprint(id);
+
+  if (!blueprint) {
+    return NextResponse.json(
+      { error: "Blueprint not found" },
+      { status: 404 }
+    );
+  }
+
+  return NextResponse.json(blueprint);
+}
+
+export async function DELETE(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    deleteBlueprint(id);
+    return NextResponse.json({ ok: true });
+  } catch (err: unknown) {
+    const message =
+      err instanceof Error ? err.message : "Failed to delete blueprint";
+    const status = message.includes("built-in") ? 403 : 400;
+    return NextResponse.json({ error: message }, { status });
+  }
+}

package/src/app/api/blueprints/import/route.ts

@@ -0,0 +1,68 @@
+import { NextRequest, NextResponse } from "next/server";
+import { createBlueprint } from "@/lib/workflows/blueprints/registry";
+
+/**
+ * POST /api/blueprints/import
+ *
+ * Import a blueprint from a GitHub URL pointing to a YAML file.
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const { url } = await req.json();
+
+    if (!url || typeof url !== "string") {
+      return NextResponse.json({ error: "url is required" }, { status: 400 });
+    }
+
+    const rawUrl = toRawGitHubUrl(url);
+    if (!rawUrl) {
+      return NextResponse.json(
+        { error: "Only GitHub URLs are supported" },
+        { status: 400 }
+      );
+    }
+
+    const res = await fetch(rawUrl);
+    if (!res.ok) {
+      return NextResponse.json(
+        { error: `Failed to fetch blueprint: ${res.status}` },
+        { status: 400 }
+      );
+    }
+
+    const yamlContent = await res.text();
+    const blueprint = createBlueprint(yamlContent);
+
+    return NextResponse.json(
+      { ok: true, id: blueprint.id, name: blueprint.name },
+      { status: 201 }
+    );
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : "Import failed";
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}
+
+function toRawGitHubUrl(url: string): string | null {
+  try {
+    const u = new URL(url);
+
+    if (u.hostname === "raw.githubusercontent.com") {
+      return url;
+    }
+
+    if (u.hostname !== "github.com") return null;
+
+    const match = u.pathname.match(
+      /^\/([^/]+)\/([^/]+)\/(tree|blob)\/([^/]+)\/(.+)/
+    );
+    if (match) {
+      const [, owner, repo, , branch, filePath] = match;
+      return `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${filePath}`;
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}

package/src/app/api/blueprints/route.ts

@@ -0,0 +1,29 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  listBlueprints,
+  createBlueprint,
+} from "@/lib/workflows/blueprints/registry";
+
+export async function GET() {
+  const blueprints = listBlueprints();
+  return NextResponse.json(blueprints);
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const { yaml: yamlContent } = await req.json();
+    if (!yamlContent || typeof yamlContent !== "string") {
+      return NextResponse.json(
+        { error: "yaml field is required" },
+        { status: 400 }
+      );
+    }
+
+    const blueprint = createBlueprint(yamlContent);
+    return NextResponse.json(blueprint, { status: 201 });
+  } catch (err: unknown) {
+    const message =
+      err instanceof Error ? err.message : "Failed to create blueprint";
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

package/src/app/api/command-palette/recent/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { projects, tasks } from "@/lib/db/schema";
+import { desc } from "drizzle-orm";
+
+export async function GET() {
+  const recentProjects = await db
+    .select({
+      id: projects.id,
+      name: projects.name,
+      status: projects.status,
+    })
+    .from(projects)
+    .orderBy(desc(projects.updatedAt))
+    .limit(5);
+
+  const recentTasks = await db
+    .select({
+      id: tasks.id,
+      title: tasks.title,
+      status: tasks.status,
+    })
+    .from(tasks)
+    .orderBy(desc(tasks.updatedAt))
+    .limit(5);
+
+  return NextResponse.json({
+    projects: recentProjects,
+    tasks: recentTasks,
+  });
+}

package/src/app/api/data/clear/route.ts

@@ -0,0 +1,22 @@
+import { NextResponse } from "next/server";
+import { clearAllData } from "@/lib/data/clear";
+
+export async function POST() {
+  if (process.env.NODE_ENV === "production") {
+    return NextResponse.json(
+      { error: "This endpoint is disabled in production" },
+      { status: 403 }
+    );
+  }
+
+  try {
+    const deleted = clearAllData();
+    return NextResponse.json({ success: true, deleted });
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json(
+      { success: false, error: message },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/data/seed/route.ts

@@ -0,0 +1,22 @@
+import { NextResponse } from "next/server";
+import { seedSampleData } from "@/lib/data/seed";
+
+export async function POST() {
+  if (process.env.NODE_ENV === "production") {
+    return NextResponse.json(
+      { error: "This endpoint is disabled in production" },
+      { status: 403 }
+    );
+  }
+
+  try {
+    const seeded = await seedSampleData();
+    return NextResponse.json({ success: true, seeded });
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json(
+      { success: false, error: message },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/documents/[id]/file/route.ts

@@ -0,0 +1,44 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { documents } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const inline = req.nextUrl.searchParams.get("inline") === "1";
+
+  const [doc] = await db
+    .select({
+      originalName: documents.originalName,
+      mimeType: documents.mimeType,
+      storagePath: documents.storagePath,
+    })
+    .from(documents)
+    .where(eq(documents.id, id));
+
+  if (!doc) {
+    return NextResponse.json({ error: "Document not found" }, { status: 404 });
+  }
+
+  try {
+    const data = await readFile(doc.storagePath);
+    const filename = basename(doc.originalName);
+    const canInline =
+      inline && (doc.mimeType.startsWith("image/") || doc.mimeType === "application/pdf");
+
+    return new NextResponse(data, {
+      headers: {
+        "Content-Type": doc.mimeType,
+        "Content-Disposition": `${canInline ? "inline" : "attachment"}; filename="${filename}"`,
+        "X-Content-Type-Options": "nosniff",
+      },
+    });
+  } catch {
+    return NextResponse.json({ error: "File not found" }, { status: 404 });
+  }
+}