@mndrk/agx 2.4.6 → 2.4.8

package/cloud-runtime/standalone/apps/local/lib/project-workspace.ts

@@ -0,0 +1,80 @@
+import type { WorkspaceEntry } from "@/lib/db/types";
+import {
+  DEFAULT_WORKSPACE_CATEGORIES,
+  getWorkspaceCategory,
+  WORKSPACE_CATEGORY_IDS,
+} from "@/lib/workspace-categories";
+
+export type ProjectWorkspace = Record<string, WorkspaceEntry[]>;
+
+export interface WorkspaceCategoryGroup {
+  id: string;
+  label: string;
+  entries: WorkspaceEntry[];
+  isPreset: boolean;
+  isEmpty: boolean;
+}
+
+export function isPresetWorkspaceCategory(category: string): boolean {
+  return WORKSPACE_CATEGORY_IDS.includes(category as (typeof WORKSPACE_CATEGORY_IDS)[number]);
+}
+
+export function formatWorkspaceCategoryLabel(category: string): string {
+  const trimmed = category.trim();
+  const preset = trimmed ? getWorkspaceCategory(trimmed as (typeof WORKSPACE_CATEGORY_IDS)[number]) : null;
+  if (preset) return preset.label;
+  if (!trimmed) return "Custom";
+
+  return trimmed
+    .replace(/[_-]+/g, " ")
+    .replace(/\s+/g, " ")
+    .replace(/\b\w/g, (char) => char.toUpperCase());
+}
+
+function sortEntries(entries: WorkspaceEntry[]): WorkspaceEntry[] {
+  return [...entries].sort((left, right) => {
+    if (left.sort_order !== right.sort_order) {
+      return left.sort_order - right.sort_order;
+    }
+    return left.name.localeCompare(right.name);
+  });
+}
+
+export function countWorkspaceEntries(workspace: ProjectWorkspace): number {
+  return Object.values(workspace).reduce((total, entries) => total + entries.length, 0);
+}
+
+export function buildWorkspaceCategoryGroups(
+  workspace: ProjectWorkspace,
+  extraCategories: string[] = [],
+): WorkspaceCategoryGroup[] {
+  const presetGroups: WorkspaceCategoryGroup[] = DEFAULT_WORKSPACE_CATEGORIES.map((category) => {
+    const entries = sortEntries(workspace[category.id] ?? []);
+    return {
+      id: category.id,
+      label: category.label,
+      entries,
+      isPreset: true,
+      isEmpty: entries.length === 0,
+    };
+  });
+
+  const customCategoryIds = [...new Set([...Object.keys(workspace), ...extraCategories])]
+    .map((category) => category.trim())
+    .filter((category) => category.length > 0)
+    .filter((category) => !isPresetWorkspaceCategory(category))
+    .sort((left, right) => formatWorkspaceCategoryLabel(left).localeCompare(formatWorkspaceCategoryLabel(right)));
+
+  const customGroups: WorkspaceCategoryGroup[] = customCategoryIds.map((category) => {
+    const entries = sortEntries(workspace[category] ?? []);
+    return {
+      id: category,
+      label: formatWorkspaceCategoryLabel(category),
+      entries,
+      isPreset: false,
+      isEmpty: entries.length === 0,
+    };
+  });
+
+  return [...presetGroups, ...customGroups];
+}

package/cloud-runtime/standalone/apps/local/lib/task-context.ts

@@ -20,8 +20,8 @@ import {
   getProjectBySlug,
   getProjectMemory,
   getProjectRepos,
+  getWorkspaceMapForContext,
   getProjectWithRepos,
-
   TaskRunHistory,
   defaultStagePrompts,
   DEFAULT_WORKFLOW_ID,
@@ -64,6 +64,11 @@ export interface StageConfig {
 export interface ProjectContext {
   project: Project | null;
   repos: ProjectRepo[];
+  workspace_map: Array<{
+    location: string;
+    path: string | null;
+    purpose: string | null;
+  }>;
   learnings: string[];
 }
 
@@ -285,6 +290,31 @@ function formatRepoLines(repos: ProjectRepo[]): string {
     .join("\n");
 }
 
+function escapeMarkdownTableCell(value: string | null | undefined): string {
+  return String(value ?? "")
+    .replace(/\r\n?/g, "\n")
+    .replace(/\|/g, "\\|")
+    .replace(/\n/g, "<br />");
+}
+
+function formatWorkspaceMapSection(
+  workspaceMap: Array<{ location: string; path: string | null; purpose: string | null }>
+): string | null {
+  const mappedRows = workspaceMap.filter((entry) => entry.path);
+  if (!mappedRows.length) return null;
+
+  const rows = mappedRows.map((entry) =>
+    `| ${escapeMarkdownTableCell(entry.location)} | ${escapeMarkdownTableCell(entry.path)} | ${escapeMarkdownTableCell(entry.purpose)} |`
+  );
+
+  return [
+    "WORKSPACE MAP",
+    "| Location | Path | Purpose |",
+    "|----------|------|---------|",
+    ...rows,
+  ].join("\n");
+}
+
 async function resolveProjectContext(task: Task, _projectLearnings: Learning[]): Promise<ProjectContext | null> {
   const projectId = task.project_id;
   const projectSlug = task.project || undefined;
@@ -306,7 +336,10 @@ async function resolveProjectContext(task: Task, _projectLearnings: Learning[]):
     return null;
   }
 
-  const projectKnowledge = await getProjectMemory(projectWithRepos.id, "human");
+  const [projectKnowledge, workspace_map] = await Promise.all([
+    getProjectMemory(projectWithRepos.id, "human"),
+    getWorkspaceMapForContext(projectWithRepos.id),
+  ]);
   const projectSystemNote = getKnowledgeNote("project", projectWithRepos.id);
 
   if (projectWithRepos.repos.length > 0) {
@@ -337,6 +370,7 @@ async function resolveProjectContext(task: Task, _projectLearnings: Learning[]):
   return {
     project: projectWithRepos,
     repos: projectWithRepos.repos ?? [],
+    workspace_map,
     learnings: [
       ...projectKnowledge.map((entry) => entry.content),
       ...(projectSystemNote?.content ? [`[System-generated] ${projectSystemNote.content}`] : []),
@@ -404,18 +438,19 @@ export function buildTaskPrompt(args: {
   const projectContextSections = project_context?.project
     ? [
       `PROJECT CONTEXT\n${formatProjectMetadata(project_context.project)}`,
+      formatWorkspaceMapSection(project_context.workspace_map),
       `REPOSITORY MAP\n${formatRepoLines(project_context.repos)}`,
       `PROJECT KNOWLEDGE\n${formatList(project_context.learnings, "(none)")}`,
-    ]
+    ].filter(Boolean)
     : [];
 
   const sections = [
     stage_config.prompt ? `STAGE PROMPT\n${stage_config.prompt}` : null,
     "EXECUTION RULES\n- Do not use AGX MCP tools or AGX MCP servers for this task.\n- Complete work using local edits, shell commands, and allowed HTTP APIs only.",
     `TASK META\n${metaLines.join("\n")}`,
+    ...projectContextSections,
     `TASK\n${description || "(empty)"}`,
     `COMMENTS\n${formatList(commentLines, "(none)")}`,
-    ...projectContextSections,
     `TASK KNOWLEDGE\n${formatList(learnings.task.map((l) => l.content), "(none)")}`,
     `GLOBAL KNOWLEDGE\n${formatList(learnings.global.map((l) => l.content), "(none)")}`,
     agent_memories?.length ? `PAST LEARNINGS (from previous tasks)\n${formatList(agent_memories, "(none)")}` : null,

package/cloud-runtime/standalone/apps/local/lib/tracker/adapters/github/adapter.tsx

@@ -234,9 +234,45 @@ export class GitHubAdapter implements TrackerAdapter {
     return [];
   }
 
-  async handleApiKeyConnect(_projectId: string, _apiKey: string): Promise<void> {
-    throw new Error(
-      "GitHub requires OAuth authentication — use the Connect button instead",
-    );
+  async handleApiKeyConnect(projectId: string, apiKey: string): Promise<void> {
+    const token = apiKey.trim();
+    if (!token) throw new Error("Personal Access Token is required");
+
+    const res = await fetch("https://api.github.com/user", {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+      },
+    });
+
+    if (res.status === 401) {
+      throw new Error("Invalid Personal Access Token");
+    }
+    if (res.status === 403) {
+      throw new Error("Token lacks required permissions or is rate-limited");
+    }
+    if (!res.ok) {
+      throw new Error(`GitHub API error (${res.status})`);
+    }
+
+    const user = (await res.json()) as { login?: string };
+    if (!user.login) {
+      throw new Error("Could not read user login from GitHub");
+    }
+
+    const scopeHeader = res.headers.get("x-oauth-scopes") ?? "";
+    const scopes = scopeHeader
+      .split(",")
+      .map((s) => s.trim())
+      .filter((s) => s.length > 0);
+
+    saveGithubTokens(projectId, {
+      accessToken: token,
+      refreshToken: null,
+      expiresAt: null,
+      login: user.login,
+      scopes,
+    });
   }
 }

package/cloud-runtime/standalone/apps/local/lib/workspace-yaml.ts

@@ -0,0 +1,164 @@
+import { dump, load } from "js-yaml";
+import type { WorkspaceEntry } from "./db";
+import { listWorkspaceCategories } from "./workspace-categories";
+
+export interface WorkspaceYamlCategory {
+  id: string;
+  label: string;
+}
+
+export interface WorkspaceYamlEntry {
+  category: string;
+  name: string;
+  purpose: string | null;
+}
+
+export interface WorkspaceYamlDocument {
+  version: 1;
+  categories: WorkspaceYamlCategory[];
+  entries: WorkspaceYamlEntry[];
+}
+
+const knownCategoryLabels = new Map<string, string>(
+  listWorkspaceCategories().map((category) => [category.id, category.label]),
+);
+
+function normalizeRequiredString(value: unknown, field: string): string {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Invalid or missing '${field}'`);
+  }
+
+  return value.trim();
+}
+
+function normalizeOptionalPurpose(value: unknown, field: string): string | null {
+  if (value === undefined || value === null) {
+    return null;
+  }
+
+  if (typeof value !== "string") {
+    throw new Error(`Invalid '${field}'`);
+  }
+
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function fallbackCategoryLabel(categoryId: string): string {
+  return categoryId
+    .split(/[_-]+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(" ") || categoryId;
+}
+
+function categoryKey(category: string, name: string): string {
+  return `${category}\u0000${name}`;
+}
+
+export function serializeWorkspace(entries: WorkspaceEntry[]): string {
+  const sortedEntries = [...entries].sort((a, b) => {
+    if (a.category !== b.category) return a.category.localeCompare(b.category);
+    if (a.sort_order !== b.sort_order) return a.sort_order - b.sort_order;
+    return a.name.localeCompare(b.name);
+  });
+
+  const categories = new Map<string, WorkspaceYamlCategory>();
+  for (const entry of sortedEntries) {
+    if (!categories.has(entry.category)) {
+      categories.set(entry.category, {
+        id: entry.category,
+        label: knownCategoryLabels.get(entry.category) ?? fallbackCategoryLabel(entry.category),
+      });
+    }
+  }
+
+  const doc: WorkspaceYamlDocument = {
+    version: 1,
+    categories: Array.from(categories.values()),
+    entries: sortedEntries.map((entry) => ({
+      category: entry.category,
+      name: entry.name,
+      purpose: entry.purpose ?? null,
+    })),
+  };
+
+  return dump(doc, {
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false,
+  });
+}
+
+export function deserializeWorkspace(yaml: string): WorkspaceYamlDocument {
+  const parsed = load(yaml);
+
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Invalid YAML: expected an object at the root level");
+  }
+
+  const doc = parsed as Record<string, unknown>;
+  if (doc.version !== 1) {
+    throw new Error(`Unsupported version: ${doc.version ?? "missing"}. Only version 1 is supported.`);
+  }
+  if (!Array.isArray(doc.categories)) {
+    throw new Error("Invalid YAML: missing or invalid 'categories' array");
+  }
+  if (!Array.isArray(doc.entries)) {
+    throw new Error("Invalid YAML: missing or invalid 'entries' array");
+  }
+
+  const seenCategories = new Set<string>();
+  const categories = doc.categories.map((entry, index) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`Invalid category entry at index ${index}`);
+    }
+
+    const category = entry as Record<string, unknown>;
+    const id = normalizeRequiredString(category.id, `categories[${index}].id`);
+    const label = normalizeRequiredString(category.label, `categories[${index}].label`);
+
+    if (seenCategories.has(id)) {
+      throw new Error(`Duplicate category id '${id}'`);
+    }
+    seenCategories.add(id);
+
+    return { id, label };
+  });
+
+  const categoryIds = new Set(categories.map((category) => category.id));
+  const seenEntries = new Set<string>();
+
+  const entries = doc.entries.map((entry, index) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`Invalid workspace entry at index ${index}`);
+    }
+
+    const workspaceEntry = entry as Record<string, unknown>;
+    if ("path" in workspaceEntry) {
+      throw new Error(`Invalid workspace entry at index ${index}: 'path' is not allowed`);
+    }
+
+    const category = normalizeRequiredString(workspaceEntry.category, `entries[${index}].category`);
+    const name = normalizeRequiredString(workspaceEntry.name, `entries[${index}].name`);
+    const purpose = normalizeOptionalPurpose(workspaceEntry.purpose, `entries[${index}].purpose`);
+
+    if (!categoryIds.has(category)) {
+      throw new Error(`Entry '${name}' references unknown category '${category}'`);
+    }
+
+    const key = categoryKey(category, name);
+    if (seenEntries.has(key)) {
+      throw new Error(`Duplicate workspace entry '${category}/${name}'`);
+    }
+    seenEntries.add(key);
+
+    return { category, name, purpose };
+  });
+
+  return {
+    version: 1,
+    categories,
+    entries,
+  };
+}

package/cloud-runtime/standalone/apps/local/src/objectives/program/index.ts

@@ -0,0 +1,7 @@
+export {
+  PROGRAM_FILENAME,
+  getProgramPath,
+  readProgram,
+  writeProgram,
+} from "./repository";
+export type { ObjectiveProgram } from "./repository";

package/cloud-runtime/standalone/apps/local/src/objectives/program/repository.ts

@@ -0,0 +1,60 @@
+import fs from "fs";
+import path from "path";
+import { homedir } from "os";
+
+export const PROGRAM_FILENAME = "program.md";
+
+function resolveAgxDataDir(): string {
+  const configured = process.env.AGX_DATA_DIR?.trim();
+  if (configured) return path.resolve(configured);
+  return path.join(homedir(), ".agx");
+}
+
+export function getProgramPath(projectSlug: string, objectiveKey: string): string {
+  return path.join(
+    resolveAgxDataDir(),
+    "projects",
+    projectSlug,
+    "objectives",
+    objectiveKey,
+    PROGRAM_FILENAME,
+  );
+}
+
+export interface ObjectiveProgram {
+  path: string;
+  content: string | null;
+  updatedAt: string | null;
+}
+
+export function readProgram(projectSlug: string, objectiveKey: string): ObjectiveProgram {
+  const filePath = getProgramPath(projectSlug, objectiveKey);
+  if (!fs.existsSync(filePath)) {
+    return { path: filePath, content: null, updatedAt: null };
+  }
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    const stat = fs.statSync(filePath);
+    return { path: filePath, content, updatedAt: stat.mtime.toISOString() };
+  } catch {
+    return { path: filePath, content: null, updatedAt: null };
+  }
+}
+
+export function writeProgram(
+  projectSlug: string,
+  objectiveKey: string,
+  content: string,
+): ObjectiveProgram {
+  const filePath = getProgramPath(projectSlug, objectiveKey);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const trimmed = content.replace(/\s+$/g, "");
+  if (trimmed.length === 0) {
+    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+    return { path: filePath, content: null, updatedAt: null };
+  }
+  const body = trimmed + "\n";
+  fs.writeFileSync(filePath, body, "utf8");
+  const stat = fs.statSync(filePath);
+  return { path: filePath, content: body, updatedAt: stat.mtime.toISOString() };
+}

package/cloud-runtime/standalone/apps/local/src/prompt-scheduler/objective-worker.ts

@@ -7,6 +7,7 @@ import {
 import { getIssueActiveAgents, type IssueActiveAgent } from '@/lib/linear-run-store';
 import { getActivityRepository } from '@/src/objectives/activities/repository';
 import { getNoteRepository } from '@/src/objectives/notes';
+import { readProgram } from '@/src/objectives/program';
 import {
   loadProjectObjectiveContext,
   persistProjectObjectiveMetadata,
@@ -220,6 +221,17 @@ export async function buildObjectiveObservation(opts: {
     `Progress: ${objective.progress}% | Status: ${objective.status}`,
   );
 
+  // PROGRAM (objective-level prompt: goal / definition of better / blast radius / learnings)
+  const program = readProgram(projectSlug, objective.key);
+  sections.push('', 'PROGRAM', `path: ${program.path}`);
+  if (program.content && program.content.trim().length > 0) {
+    sections.push(program.content.trim());
+  } else {
+    sections.push(
+      '(empty) No program has been authored for this objective yet. Before committing to a direction, surface this to the user in chat: ask what "better" means for this objective (the success metric), what paths/systems are in-scope, and any constraints. Capture the answer by writing to the path above.',
+    );
+  }
+
   // NOTES
   if (notes.length > 0) {
     sections.push(

package/cloud-runtime/standalone/apps/local/src/scheduling/status.ts

@@ -0,0 +1,42 @@
+type ScheduleState = "active" | "paused" | "stopped" | string;
+
+interface ScheduledRunStatusInput {
+  state: ScheduleState;
+  nextScheduledAt: number | null | undefined;
+  lastCompletedAt: number | null | undefined;
+  inProgress?: boolean;
+  now?: number;
+}
+
+interface IntervalScheduleStatusInput {
+  state: ScheduleState;
+  lastCompletedAt: number | null | undefined;
+  intervalMs: number;
+  inProgress?: boolean;
+  now?: number;
+}
+
+export function isScheduledRunOverdue({
+  state,
+  nextScheduledAt,
+  lastCompletedAt,
+  inProgress = false,
+  now = Date.now(),
+}: ScheduledRunStatusInput): boolean {
+  if (state !== "active" || inProgress) return false;
+  if (nextScheduledAt == null || nextScheduledAt >= now) return false;
+  if (lastCompletedAt != null && lastCompletedAt >= nextScheduledAt) return false;
+  return true;
+}
+
+export function isIntervalScheduleOverdue({
+  state,
+  lastCompletedAt,
+  intervalMs,
+  inProgress = false,
+  now = Date.now(),
+}: IntervalScheduleStatusInput): boolean {
+  if (state !== "active" || inProgress) return false;
+  if (lastCompletedAt == null) return false;
+  return lastCompletedAt + intervalMs < now;
+}

package/cloud-runtime/standalone/apps/local/worker/index.js

@@ -7904,19 +7904,22 @@ async function getProjectForThread(threadId) {
   return data?.project_id ?? null;
 }
 async function getProjectWorkspace(projectId) {
-  const db2 = createAdminDbClient();
-  const { data, error } = await db2.from("workspace_entries").select("*").eq("project_id", projectId).order("category", { ascending: true }).order("sort_order", { ascending: true }).order("name", { ascending: true });
-  if (error) {
-    if (isMissingRelationError(error, "workspace_entries")) return {};
-    throw error;
-  }
-  const entries = data || [];
+  const entries = await getProjectWorkspaceEntries(projectId);
   return entries.reduce((acc, entry) => {
     if (!acc[entry.category]) acc[entry.category] = [];
     acc[entry.category].push(entry);
     return acc;
   }, {});
 }
+async function getProjectWorkspaceEntries(projectId) {
+  const db2 = createAdminDbClient();
+  const { data, error } = await db2.from("workspace_entries").select("*").eq("project_id", projectId).order("category", { ascending: true }).order("sort_order", { ascending: true }).order("name", { ascending: true });
+  if (error) {
+    if (isMissingRelationError(error, "workspace_entries")) return [];
+    throw error;
+  }
+  return data || [];
+}
 async function createWorkspaceEntry(projectId, entry) {
   const db2 = createAdminDbClient();
   const id = (0, import_crypto.randomUUID)();
@@ -7928,7 +7931,7 @@ async function createWorkspaceEntry(projectId, entry) {
     name: entry.name,
     path: entry.path || null,
     purpose: entry.purpose || null,
-    sort_order: 0,
+    sort_order: entry.sort_order ?? 0,
     created_at: now,
     updated_at: now
   }).select().single();
@@ -7942,6 +7945,7 @@ async function updateWorkspaceEntry(projectId, entryId, updates) {
   if (updates.path !== void 0) payload.path = updates.path;
   if (updates.purpose !== void 0) payload.purpose = updates.purpose;
   if (updates.sort_order !== void 0) payload.sort_order = updates.sort_order;
+  payload.updated_at = (/* @__PURE__ */ new Date()).toISOString();
   const { data, error } = await db2.from("workspace_entries").update(payload).eq("id", entryId).eq("project_id", projectId).select().single();
   if (error) {
     if (error.code === "PGRST116") return null;
@@ -9138,6 +9142,7 @@ __export(db_exports, {
   getProjectVariables: () => getProjectVariables,
   getProjectWithRepos: () => getProjectWithRepos,
   getProjectWorkspace: () => getProjectWorkspace,
+  getProjectWorkspaceEntries: () => getProjectWorkspaceEntries,
   getProjects: () => getProjects,
   getStagePrompt: () => getStagePrompt,
   getStagePrompts: () => getStagePrompts,
@@ -13032,6 +13037,7 @@ async function saveThreadRepoSelections(rootMessageId, repoIds) {
 var import_fs12, import_path12, import_os12, DatabaseSyncCtor5, HISTORY_DIR2, DB_PATH3, LEGACY_THREAD_ID, REACTION_TYPES, ACTIVE_AGENT_PROCESS_STALE_MS, ACTIVE_CHAT_RUN_STALE_MS, ALLOWED_TRANSITIONS, ReactionStoreError, withDatabase;
 var init_history_store = __esm({
   "apps/local/lib/history-store.ts"() {
+    "use strict";
     init_sqlite_compat();
     import_fs12 = require("fs");
     import_path12 = __toESM(require("path"));
@@ -13057,7 +13063,6 @@ var init_history_store = __esm({
       blocked: /* @__PURE__ */ new Set(["ack", "blocked", "working"])
     };
     ReactionStoreError = class extends Error {
-      status;
       constructor(message, status) {
         super(message);
         this.name = "ReactionStoreError";