@mndrk/agx 2.0.47 → 2.0.48

package/cloud-runtime/standalone/lib/linear-execution-prompt.ts

@@ -29,6 +29,26 @@ export interface LinearExecutionPromptInput {
   runtime?: LinearExecutionRuntimeContext | null;
 }
 
+export interface ResolvedLinearExecutionContext {
+  issue: {
+    identifier: string;
+    title: string;
+    status: string;
+    assignee: string;
+  };
+  project: {
+    name: string;
+    slug: string;
+    label: string;
+    repos: LinearExecutionProjectRepoContext[];
+  };
+  runtime: {
+    knowledgeBaseRoot: string;
+    issueKnowledgePath: string;
+    isolatedWorktreePath: string;
+  };
+}
+
 function slugifySegment(value: string, fallback: string): string {
   const slug = value
     .trim()
@@ -95,19 +115,14 @@ export function buildLinearExecutionPrompt(input: LinearExecutionPromptInput): {
   prompt: string;
   promptPrefix: string;
 } {
-  const issueIdentifier = input.issue.identifier.trim() || "TICKET-ID";
-  const issueTitle = input.issue.title.trim() || "Untitled ticket";
-  const issueStatus = String(input.issue.status ?? "").trim() || "Unknown";
-  const issueAssignee = String(input.issue.assignee ?? "").trim() || "Unassigned";
-  const projectSlug = toProjectSlug(input.project);
-  const knowledgeBaseRoot =
-    String(input.runtime?.knowledgeBaseRoot ?? "").trim() || `~/.agx/vault/${projectSlug}`;
-  const issueKnowledgePath =
-    String(input.runtime?.issueKnowledgePath ?? "").trim() ||
-    `${knowledgeBaseRoot}/issues/${issueIdentifier}/`;
-  const isolatedWorktreePath =
-    String(input.runtime?.isolatedWorktreePath ?? "").trim() ||
-    `/tmp/agx-${slugifySegment(issueIdentifier, "ticket")}`;
+  const context = resolveLinearExecutionContext(input);
+  const issueIdentifier = context.issue.identifier;
+  const issueTitle = context.issue.title;
+  const issueStatus = context.issue.status;
+  const issueAssignee = context.issue.assignee;
+  const knowledgeBaseRoot = context.runtime.knowledgeBaseRoot;
+  const issueKnowledgePath = context.runtime.issueKnowledgePath;
+  const isolatedWorktreePath = context.runtime.isolatedWorktreePath;
 
   const promptPrefix = [
     "LINEAR TASK EXECUTION",
@@ -118,13 +133,13 @@ export function buildLinearExecutionPrompt(input: LinearExecutionPromptInput): {
       `- Title: ${issueTitle}`,
       `- Current status: ${issueStatus}`,
       `- Current assignee: ${issueAssignee}`,
-      `- Project: ${toProjectLabel(input.project)}`,
+      `- Project: ${context.project.label}`,
       `- Knowledge base root: ${knowledgeBaseRoot}`,
       `- Issue knowledge path: ${issueKnowledgePath}`,
       `- Suggested isolated worktree: ${isolatedWorktreePath}`,
       "- Additional project resources such as repo knowledge, project memory, and project variables are injected separately by the active project context.",
     ].join("\n"),
-    `SOURCE REPOSITORIES\n${formatRepositories(input.project?.repos)}`,
+    `SOURCE REPOSITORIES\n${formatRepositories(context.project.repos)}`,
     [
       "WORKFLOW",
       "1. Read the full Linear issue and comment thread before acting. Use Linear MCP for issue details, comments, state changes, and follow-up.",
@@ -151,3 +166,65 @@ export function buildLinearExecutionPrompt(input: LinearExecutionPromptInput): {
     promptPrefix,
   };
 }
+
+export function resolveLinearExecutionContext(
+  input: LinearExecutionPromptInput
+): ResolvedLinearExecutionContext {
+  const issueIdentifier = input.issue.identifier.trim() || "TICKET-ID";
+  const issueTitle = input.issue.title.trim() || "Untitled ticket";
+  const issueStatus = String(input.issue.status ?? "").trim() || "Unknown";
+  const issueAssignee = String(input.issue.assignee ?? "").trim() || "Unassigned";
+  const projectSlug = toProjectSlug(input.project);
+  const projectName = String(input.project?.name ?? "").trim() || projectSlug;
+  const knowledgeBaseRoot =
+    String(input.runtime?.knowledgeBaseRoot ?? "").trim() || `~/.agx/vault/${projectSlug}`;
+  const issueKnowledgePath =
+    String(input.runtime?.issueKnowledgePath ?? "").trim() ||
+    `${knowledgeBaseRoot}/issues/${issueIdentifier}/`;
+  const isolatedWorktreePath =
+    String(input.runtime?.isolatedWorktreePath ?? "").trim() ||
+    `/tmp/agx-${slugifySegment(issueIdentifier, "ticket")}`;
+
+  return {
+    issue: {
+      identifier: issueIdentifier,
+      title: issueTitle,
+      status: issueStatus,
+      assignee: issueAssignee,
+    },
+    project: {
+      name: projectName,
+      slug: projectSlug,
+      label: toProjectLabel(input.project),
+      repos: input.project?.repos ? [...input.project.repos] : [],
+    },
+    runtime: {
+      knowledgeBaseRoot,
+      issueKnowledgePath,
+      isolatedWorktreePath,
+    },
+  };
+}
+
+export function renderLinearExecutionPromptTemplate(
+  template: string,
+  input: LinearExecutionPromptInput
+): string {
+  const context = resolveLinearExecutionContext(input);
+  const values: Record<string, string> = {
+    "ticket.identifier": context.issue.identifier,
+    "ticket.title": context.issue.title,
+    "ticket.status": context.issue.status,
+    "ticket.assignee": context.issue.assignee,
+    "project.name": context.project.name,
+    "project.slug": context.project.slug,
+    "project.label": context.project.label,
+    "knowledge_base.root": context.runtime.knowledgeBaseRoot,
+    "knowledge_base.issue_path": context.runtime.issueKnowledgePath,
+    "worktree.path": context.runtime.isolatedWorktreePath,
+  };
+
+  return template.replace(/\{\{\s*([a-zA-Z0-9._-]+)\s*\}\}/g, (_match, key: string) => {
+    return values[key] ?? "";
+  });
+}

package/cloud-runtime/standalone/state/automations/.state/c4300b01-1203-40fe-b3a9-b9fb9ec0c5cc.json

@@ -0,0 +1,8 @@
+{
+  "scheduleHash": "218b10daaa347ad14c3a8fbaabee0cff119839d6f5b6c5c3aaf7ed2eac4484f1",
+  "nextRunAt": 1775643300000,
+  "lastRunAt": null,
+  "lastOutcome": null,
+  "lastError": null,
+  "updatedAt": "2026-04-08T09:50:53.809Z"
+}

package/cloud-runtime/standalone/state/automations/active/c4300b01-1203-40fe-b3a9-b9fb9ec0c5cc.md

@@ -0,0 +1,15 @@
+---
+id: c4300b01-1203-40fe-b3a9-b9fb9ec0c5cc
+name: 'Agx Agent: Work On Linear Tickets'
+projectId: f354bbf2-cfed-473f-890c-e592209313da
+state: active
+trigger:
+  type: scheduled
+  cadence: 15 * * * *
+  cronExpr: 15 * * * *
+target:
+  type: prompt_job
+  provider: claude
+createdAt: '2026-04-08T09:50:53.793Z'
+---
+Execute `/Users/mendrika/Projects/Agents/agx-game-vault/agx-game-vault/scheduled-tasks/work-linear-tickets.md`

package/cloud-runtime/standalone/state/linearRunScripts.test.ts

@@ -0,0 +1,99 @@
+import {
+  getLinearRunScriptsStorageKey,
+  loadLinearRunScripts,
+  persistLinearRunScripts,
+} from "./linearRunScripts";
+
+type LocalStorageMap = Record<string, string>;
+
+function withFakeLocalStorage<T>(callback: (storage: LocalStorageMap) => T): T {
+  const originalWindow = globalThis.window;
+  const storage: LocalStorageMap = {};
+  const fakeLocalStorage = {
+    getItem(key: string) {
+      return storage[key] ?? null;
+    },
+    setItem(key: string, value: string) {
+      storage[key] = value;
+    },
+    removeItem(key: string) {
+      delete storage[key];
+    },
+  };
+  globalThis.window = { localStorage: fakeLocalStorage } as unknown as Window;
+
+  try {
+    return callback(storage);
+  } finally {
+    globalThis.window = originalWindow;
+  }
+}
+
+describe("linearRunScripts", () => {
+  test("persists and restores scripts per project slug", () => {
+    withFakeLocalStorage((storage) => {
+      const key = getLinearRunScriptsStorageKey("agx-cloud");
+      expect(loadLinearRunScripts("agx-cloud")).toEqual({
+        activeScriptId: null,
+        scripts: [],
+      });
+
+      persistLinearRunScripts("agx-cloud", {
+        activeScriptId: "script-1",
+        scripts: [
+          {
+            id: "script-1",
+            name: "Investigation",
+            prompt: "Read {{ticket.identifier}} first.",
+            createdAt: "2026-04-08T01:00:00.000Z",
+            updatedAt: "2026-04-08T02:00:00.000Z",
+          },
+        ],
+      });
+
+      expect(storage[key]).toContain("Investigation");
+      expect(loadLinearRunScripts("agx-cloud")).toEqual({
+        activeScriptId: "script-1",
+        scripts: [
+          {
+            id: "script-1",
+            name: "Investigation",
+            prompt: "Read {{ticket.identifier}} first.",
+            createdAt: "2026-04-08T01:00:00.000Z",
+            updatedAt: "2026-04-08T02:00:00.000Z",
+          },
+        ],
+      });
+    });
+  });
+
+  test("clears invalid active script ids while preserving valid scripts", () => {
+    withFakeLocalStorage((storage) => {
+      storage[getLinearRunScriptsStorageKey("agx-cloud")] = JSON.stringify({
+        activeScriptId: "missing-script",
+        scripts: [
+          {
+            id: "script-1",
+            name: "Implementation",
+            prompt: "Implement carefully.",
+            createdAt: "2026-04-08T01:00:00.000Z",
+            updatedAt: "2026-04-08T02:00:00.000Z",
+          },
+        ],
+      });
+
+      expect(loadLinearRunScripts("agx-cloud")).toEqual({
+        activeScriptId: null,
+        scripts: [
+          {
+            id: "script-1",
+            name: "Implementation",
+            prompt: "Implement carefully.",
+            createdAt: "2026-04-08T01:00:00.000Z",
+            updatedAt: "2026-04-08T02:00:00.000Z",
+          },
+        ],
+      });
+    });
+  });
+});

package/cloud-runtime/standalone/state/linearRunScripts.ts

@@ -0,0 +1,132 @@
+const LINEAR_RUN_SCRIPTS_STORAGE_PREFIX = "agx-linear:runScripts";
+
+export interface LinearRunScript {
+  id: string;
+  name: string;
+  prompt: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface LinearRunScriptsState {
+  activeScriptId: string | null;
+  scripts: LinearRunScript[];
+}
+
+const DEFAULT_LINEAR_RUN_SCRIPTS_STATE: LinearRunScriptsState = {
+  activeScriptId: null,
+  scripts: [],
+};
+
+function isStorageAvailable(): boolean {
+  return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+}
+
+function normalizeProjectSlug(projectSlug?: string | null): string {
+  return String(projectSlug ?? "").trim().toLowerCase();
+}
+
+function normalizeScript(input: unknown): LinearRunScript | null {
+  if (!input || typeof input !== "object") {
+    return null;
+  }
+
+  const candidate = input as Partial<LinearRunScript>;
+  const id = typeof candidate.id === "string" ? candidate.id.trim() : "";
+  const name = typeof candidate.name === "string" ? candidate.name.trim() : "";
+  const prompt = typeof candidate.prompt === "string" ? candidate.prompt.trim() : "";
+  const createdAt =
+    typeof candidate.createdAt === "string" && candidate.createdAt.trim()
+      ? candidate.createdAt.trim()
+      : "";
+  const updatedAt =
+    typeof candidate.updatedAt === "string" && candidate.updatedAt.trim()
+      ? candidate.updatedAt.trim()
+      : createdAt;
+
+  if (!id || !name || !prompt || !createdAt || !updatedAt) {
+    return null;
+  }
+
+  return {
+    id,
+    name,
+    prompt,
+    createdAt,
+    updatedAt,
+  };
+}
+
+function sortScripts(scripts: LinearRunScript[]): LinearRunScript[] {
+  return [...scripts].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+
+function normalizeState(value: unknown): LinearRunScriptsState {
+  if (!value || typeof value !== "object") {
+    return { ...DEFAULT_LINEAR_RUN_SCRIPTS_STATE };
+  }
+
+  const candidate = value as Partial<LinearRunScriptsState>;
+  const scripts = Array.isArray(candidate.scripts)
+    ? sortScripts(
+        candidate.scripts
+          .map((script) => normalizeScript(script))
+          .filter((script): script is LinearRunScript => Boolean(script))
+      )
+    : [];
+  const activeScriptId =
+    typeof candidate.activeScriptId === "string" && candidate.activeScriptId.trim()
+      ? candidate.activeScriptId.trim()
+      : null;
+
+  return {
+    activeScriptId:
+      activeScriptId && scripts.some((script) => script.id === activeScriptId)
+        ? activeScriptId
+        : null,
+    scripts,
+  };
+}
+
+export function getLinearRunScriptsStorageKey(projectSlug?: string | null): string {
+  const normalizedProjectSlug = normalizeProjectSlug(projectSlug);
+  return normalizedProjectSlug
+    ? `${LINEAR_RUN_SCRIPTS_STORAGE_PREFIX}:${normalizedProjectSlug}`
+    : `${LINEAR_RUN_SCRIPTS_STORAGE_PREFIX}:global`;
+}
+
+export function loadLinearRunScripts(projectSlug?: string | null): LinearRunScriptsState {
+  if (!isStorageAvailable()) {
+    return { ...DEFAULT_LINEAR_RUN_SCRIPTS_STATE };
+  }
+
+  const raw = window.localStorage.getItem(getLinearRunScriptsStorageKey(projectSlug));
+  if (!raw) {
+    return { ...DEFAULT_LINEAR_RUN_SCRIPTS_STATE };
+  }
+
+  try {
+    return normalizeState(JSON.parse(raw));
+  } catch {
+    return { ...DEFAULT_LINEAR_RUN_SCRIPTS_STATE };
+  }
+}
+
+export function persistLinearRunScripts(
+  projectSlug: string | null | undefined,
+  state: LinearRunScriptsState
+): void {
+  if (!isStorageAvailable()) {
+    return;
+  }
+
+  try {
+    const normalized = normalizeState(state);
+    window.localStorage.setItem(
+      getLinearRunScriptsStorageKey(projectSlug),
+      JSON.stringify(normalized)
+    );
+  } catch {
+    // ignore storage errors
+  }
+}

package/cloud-runtime/standalone/state/windowState.ts

@@ -18,6 +18,8 @@ export interface SidebarState {
   logPanelHeight: number;
   workspaceVisible: boolean;
   logPanelVisible: boolean;
+  linearTicketPanelWidth: number;
+  linearRunsPanelWidth: number;
 }
 
 export interface ScrollState {
@@ -36,6 +38,8 @@ const DEFAULT_SIDEBAR: SidebarState = {
   logPanelHeight: 200,
   workspaceVisible: true,
   logPanelVisible: false,
+  linearTicketPanelWidth: 576,
+  linearRunsPanelWidth: 224,
 };
 
 const DEFAULT_SCROLL: ScrollState = {
@@ -172,6 +176,23 @@ export function persistLastWorkspaceId(workspaceId: string | null): void {
   persistScrollState({ lastWorkspaceId: workspaceId });
 }
 
+// Linear panel widths
+export function loadLinearTicketPanelWidth(): number {
+  return loadSidebarState().linearTicketPanelWidth;
+}
+
+export function persistLinearTicketPanelWidth(width: number): void {
+  persistSidebarState({ linearTicketPanelWidth: width });
+}
+
+export function loadLinearRunsPanelWidth(): number {
+  return loadSidebarState().linearRunsPanelWidth;
+}
+
+export function persistLinearRunsPanelWidth(width: number): void {
+  persistSidebarState({ linearRunsPanelWidth: width });
+}
+
 // Clear all window state (for logout/reset)
 export function clearWindowState(): void {
   if (!isStorageAvailable()) return;