corporateai 0.0.1

package/ui/src/lib/company-export-selection.ts

@@ -0,0 +1,57 @@
+import type { CompanyPortabilityIssueManifestEntry } from "@corporateai/shared";
+
+function isTaskPath(filePath: string): boolean {
+  return /(?:^|\/)tasks\//.test(filePath);
+}
+
+function buildRecurringTaskPrefixes(
+  issues: Array<Pick<CompanyPortabilityIssueManifestEntry, "path" | "recurring">>,
+): Set<string> {
+  const prefixes = new Set<string>();
+
+  for (const issue of issues) {
+    if (!issue.recurring) continue;
+
+    const filePath = issue.path.trim();
+    if (!filePath) continue;
+
+    prefixes.add(filePath);
+
+    const lastSlash = filePath.lastIndexOf("/");
+    if (lastSlash >= 0) {
+      prefixes.add(`${filePath.slice(0, lastSlash + 1)}`);
+    }
+  }
+
+  return prefixes;
+}
+
+function isRecurringTaskFile(filePath: string, recurringTaskPrefixes: Set<string>): boolean {
+  for (const prefix of recurringTaskPrefixes) {
+    if (filePath === prefix || filePath.startsWith(prefix)) return true;
+  }
+  return false;
+}
+
+export function buildInitialExportCheckedFiles(
+  filePaths: string[],
+  issues: Array<Pick<CompanyPortabilityIssueManifestEntry, "path" | "recurring">>,
+  previousCheckedFiles: Set<string>,
+): Set<string> {
+  const next = new Set<string>();
+  const recurringTaskPrefixes = buildRecurringTaskPrefixes(issues);
+
+  for (const filePath of filePaths) {
+    if (previousCheckedFiles.has(filePath)) {
+      next.add(filePath);
+      continue;
+    }
+
+    if (!isTaskPath(filePath) || isRecurringTaskFile(filePath, recurringTaskPrefixes)) {
+      next.add(filePath);
+    }
+  }
+
+  return next;
+}
+

package/ui/src/lib/company-page-memory.ts

@@ -0,0 +1,65 @@
+import {
+  extractCompanyPrefixFromPath,
+  normalizeCompanyPrefix,
+  toCompanyRelativePath,
+} from "./company-routes";
+
+const GLOBAL_SEGMENTS = new Set(["auth", "invite", "board-claim", "cli-auth", "docs"]);
+
+export function isRememberableCompanyPath(path: string): boolean {
+  const pathname = path.split("?")[0] ?? "";
+  const segments = pathname.split("/").filter(Boolean);
+  if (segments.length === 0) return true;
+  const [root] = segments;
+  if (GLOBAL_SEGMENTS.has(root!)) return false;
+  return true;
+}
+
+function findCompanyByPrefix<T extends { id: string; issuePrefix: string }>(params: {
+  companies: T[];
+  companyPrefix: string;
+}): T | null {
+  const normalizedPrefix = normalizeCompanyPrefix(params.companyPrefix);
+  return params.companies.find((company) => normalizeCompanyPrefix(company.issuePrefix) === normalizedPrefix) ?? null;
+}
+
+export function getRememberedPathOwnerCompanyId<T extends { id: string; issuePrefix: string }>(params: {
+  companies: T[];
+  pathname: string;
+  fallbackCompanyId: string | null;
+}): string | null {
+  const routeCompanyPrefix = extractCompanyPrefixFromPath(params.pathname);
+  if (!routeCompanyPrefix) {
+    return params.fallbackCompanyId;
+  }
+
+  return findCompanyByPrefix({
+    companies: params.companies,
+    companyPrefix: routeCompanyPrefix,
+  })?.id ?? null;
+}
+
+export function sanitizeRememberedPathForCompany(params: {
+  path: string | null | undefined;
+  companyPrefix: string;
+}): string {
+  const relativePath = params.path ? toCompanyRelativePath(params.path) : "/dashboard";
+  if (!isRememberableCompanyPath(relativePath)) {
+    return "/dashboard";
+  }
+
+  const pathname = relativePath.split("?")[0] ?? "";
+  const segments = pathname.split("/").filter(Boolean);
+  const [root, entityId] = segments;
+  if (root === "issues" && entityId) {
+    const identifierMatch = /^([A-Za-z]+)-\d+$/.exec(entityId);
+    if (
+      identifierMatch &&
+      normalizeCompanyPrefix(identifierMatch[1] ?? "") !== normalizeCompanyPrefix(params.companyPrefix)
+    ) {
+      return "/dashboard";
+    }
+  }
+
+  return relativePath;
+}

package/ui/src/lib/company-portability-sidebar.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest";
+import type { Agent, Project } from "@corporateai/shared";
+import {
+  buildPortableAgentSlugMap,
+  buildPortableProjectSlugMap,
+  buildPortableSidebarOrder,
+} from "./company-portability-sidebar";
+
+function makeAgent(id: string, name: string): Agent {
+  return {
+    id,
+    companyId: "company-1",
+    name,
+    role: "engineer",
+    title: null,
+    icon: null,
+    status: "idle",
+    reportsTo: null,
+    capabilities: null,
+    adapterType: "process",
+    adapterConfig: {},
+    runtimeConfig: {},
+    budgetMonthlyCents: 0,
+    spentMonthlyCents: 0,
+    pauseReason: null,
+    pausedAt: null,
+    permissions: { canCreateAgents: false },
+    lastHeartbeatAt: null,
+    metadata: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    urlKey: name.toLowerCase(),
+  };
+}
+
+function makeProject(id: string, name: string): Project {
+  return {
+    id,
+    companyId: "company-1",
+    goalId: null,
+    urlKey: name.toLowerCase(),
+    name,
+    description: null,
+    status: "planned",
+    leadAgentId: null,
+    targetDate: null,
+    color: null,
+    pauseReason: null,
+    pausedAt: null,
+    executionWorkspacePolicy: null,
+    archivedAt: null,
+    goalIds: [],
+    goals: [],
+    primaryWorkspace: null,
+    workspaces: [],
+    codebase: {
+      workspaceId: null,
+      repoUrl: null,
+      repoRef: null,
+      defaultRef: null,
+      repoName: null,
+      localFolder: null,
+      managedFolder: "/tmp/managed",
+      effectiveLocalFolder: "/tmp/managed",
+      origin: "managed_checkout",
+    },
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+}
+
+describe("company portability sidebar order", () => {
+  it("uses the same unique slug allocation as export and preserves the requested order", () => {
+    const alphaOne = makeAgent("agent-1", "Alpha");
+    const alphaTwo = makeAgent("agent-2", "Alpha");
+    const beta = makeAgent("agent-3", "Beta");
+    const launch = makeProject("project-1", "Launch");
+    const launchTwo = makeProject("project-2", "Launch");
+
+    expect(Array.from(buildPortableAgentSlugMap([alphaOne, alphaTwo, beta]).entries())).toEqual([
+      ["agent-1", "alpha"],
+      ["agent-2", "alpha-2"],
+      ["agent-3", "beta"],
+    ]);
+    expect(Array.from(buildPortableProjectSlugMap([launch, launchTwo]).entries())).toEqual([
+      ["project-1", "launch"],
+      ["project-2", "launch-2"],
+    ]);
+
+    expect(buildPortableSidebarOrder({
+      agents: [alphaOne, alphaTwo, beta],
+      orderedAgents: [beta, alphaTwo, alphaOne],
+      projects: [launch, launchTwo],
+      orderedProjects: [launchTwo, launch],
+    })).toEqual({
+      agents: ["beta", "alpha-2", "alpha"],
+      projects: ["launch-2", "launch"],
+    });
+  });
+});
+

package/ui/src/lib/company-portability-sidebar.ts

@@ -0,0 +1,62 @@
+import type { Agent, CompanyPortabilitySidebarOrder, Project } from "@corporateai/shared";
+import { deriveProjectUrlKey, normalizeAgentUrlKey } from "@corporateai/shared";
+
+function uniqueSlug(base: string, used: Set<string>) {
+  if (!used.has(base)) {
+    used.add(base);
+    return base;
+  }
+
+  let index = 2;
+  while (true) {
+    const candidate = `${base}-${index}`;
+    if (!used.has(candidate)) {
+      used.add(candidate);
+      return candidate;
+    }
+    index += 1;
+  }
+}
+
+export function buildPortableAgentSlugMap(agents: Agent[]): Map<string, string> {
+  const usedSlugs = new Set<string>();
+  const byId = new Map<string, string>();
+  const sortedAgents = [...agents].sort((left, right) => left.name.localeCompare(right.name));
+
+  for (const agent of sortedAgents) {
+    const baseSlug = normalizeAgentUrlKey(agent.name) ?? "agent";
+    byId.set(agent.id, uniqueSlug(baseSlug, usedSlugs));
+  }
+
+  return byId;
+}
+
+export function buildPortableProjectSlugMap(projects: Project[]): Map<string, string> {
+  const usedSlugs = new Set<string>();
+  const byId = new Map<string, string>();
+  const sortedProjects = [...projects].sort((left, right) => left.name.localeCompare(right.name));
+
+  for (const project of sortedProjects) {
+    const baseSlug = deriveProjectUrlKey(project.name, project.name);
+    byId.set(project.id, uniqueSlug(baseSlug, usedSlugs));
+  }
+
+  return byId;
+}
+
+export function buildPortableSidebarOrder(input: {
+  agents: Agent[];
+  orderedAgents: Agent[];
+  projects: Project[];
+  orderedProjects: Project[];
+}): CompanyPortabilitySidebarOrder | undefined {
+  const agentSlugById = buildPortableAgentSlugMap(input.agents);
+  const projectSlugById = buildPortableProjectSlugMap(input.projects);
+  const sidebar = {
+    agents: input.orderedAgents.map((agent) => agentSlugById.get(agent.id)).filter((slug): slug is string => Boolean(slug)),
+    projects: input.orderedProjects.map((project) => projectSlugById.get(project.id)).filter((slug): slug is string => Boolean(slug)),
+  };
+
+  return sidebar.agents.length > 0 || sidebar.projects.length > 0 ? sidebar : undefined;
+}
+

package/ui/src/lib/company-routes.ts

@@ -0,0 +1,88 @@
+const BOARD_ROUTE_ROOTS = new Set([
+  "dashboard",
+  "companies",
+  "company",
+  "skills",
+  "org",
+  "agents",
+  "projects",
+  "issues",
+  "routines",
+  "goals",
+  "approvals",
+  "costs",
+  "usage",
+  "activity",
+  "inbox",
+  "design-guide",
+]);
+
+const GLOBAL_ROUTE_ROOTS = new Set(["auth", "invite", "board-claim", "cli-auth", "docs", "instance"]);
+
+export function normalizeCompanyPrefix(prefix: string): string {
+  return prefix.trim().toUpperCase();
+}
+
+function splitPath(path: string): { pathname: string; search: string; hash: string } {
+  const match = path.match(/^([^?#]*)(\?[^#]*)?(#.*)?$/);
+  return {
+    pathname: match?.[1] ?? path,
+    search: match?.[2] ?? "",
+    hash: match?.[3] ?? "",
+  };
+}
+
+function getRootSegment(pathname: string): string | null {
+  const segment = pathname.split("/").filter(Boolean)[0];
+  return segment ?? null;
+}
+
+export function isGlobalPath(pathname: string): boolean {
+  if (pathname === "/") return true;
+  const root = getRootSegment(pathname);
+  if (!root) return true;
+  return GLOBAL_ROUTE_ROOTS.has(root.toLowerCase());
+}
+
+export function isBoardPathWithoutPrefix(pathname: string): boolean {
+  const root = getRootSegment(pathname);
+  if (!root) return false;
+  return BOARD_ROUTE_ROOTS.has(root.toLowerCase());
+}
+
+export function extractCompanyPrefixFromPath(pathname: string): string | null {
+  const segments = pathname.split("/").filter(Boolean);
+  if (segments.length === 0) return null;
+  const first = segments[0]!.toLowerCase();
+  if (GLOBAL_ROUTE_ROOTS.has(first) || BOARD_ROUTE_ROOTS.has(first)) {
+    return null;
+  }
+  return normalizeCompanyPrefix(segments[0]!);
+}
+
+export function applyCompanyPrefix(path: string, companyPrefix: string | null | undefined): string {
+  const { pathname, search, hash } = splitPath(path);
+  if (!pathname.startsWith("/")) return path;
+  if (isGlobalPath(pathname)) return path;
+  if (!companyPrefix) return path;
+
+  const prefix = normalizeCompanyPrefix(companyPrefix);
+  const activePrefix = extractCompanyPrefixFromPath(pathname);
+  if (activePrefix) return path;
+
+  return `/${prefix}${pathname}${search}${hash}`;
+}
+
+export function toCompanyRelativePath(path: string): string {
+  const { pathname, search, hash } = splitPath(path);
+  const segments = pathname.split("/").filter(Boolean);
+
+  if (segments.length >= 2) {
+    const second = segments[1]!.toLowerCase();
+    if (!GLOBAL_ROUTE_ROOTS.has(segments[0]!.toLowerCase()) && BOARD_ROUTE_ROOTS.has(second)) {
+      return `/${segments.slice(1).join("/")}${search}${hash}`;
+    }
+  }
+
+  return `${pathname}${search}${hash}`;
+}

package/ui/src/lib/company-selection.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { shouldSyncCompanySelectionFromRoute } from "./company-selection";
+
+describe("shouldSyncCompanySelectionFromRoute", () => {
+  it("does not resync when selection already matches the route", () => {
+    expect(
+      shouldSyncCompanySelectionFromRoute({
+        selectionSource: "route_sync",
+        selectedCompanyId: "pap",
+        routeCompanyId: "pap",
+      }),
+    ).toBe(false);
+  });
+
+  it("defers route sync while a manual company switch is in flight", () => {
+    expect(
+      shouldSyncCompanySelectionFromRoute({
+        selectionSource: "manual",
+        selectedCompanyId: "pap",
+        routeCompanyId: "ret",
+      }),
+    ).toBe(false);
+  });
+
+  it("syncs back to the route company for non-manual mismatches", () => {
+    expect(
+      shouldSyncCompanySelectionFromRoute({
+        selectionSource: "route_sync",
+        selectedCompanyId: "pap",
+        routeCompanyId: "ret",
+      }),
+    ).toBe(true);
+  });
+});

package/ui/src/lib/company-selection.ts

@@ -0,0 +1,18 @@
+export type CompanySelectionSource = "manual" | "route_sync" | "bootstrap";
+
+export function shouldSyncCompanySelectionFromRoute(params: {
+  selectionSource: CompanySelectionSource;
+  selectedCompanyId: string | null;
+  routeCompanyId: string;
+}): boolean {
+  const { selectionSource, selectedCompanyId, routeCompanyId } = params;
+
+  if (selectedCompanyId === routeCompanyId) return false;
+
+  // Let manual company switches finish their remembered-path navigation first.
+  if (selectionSource === "manual" && selectedCompanyId) {
+    return false;
+  }
+
+  return true;
+}

package/ui/src/lib/groupBy.ts

@@ -0,0 +1,11 @@
+export function groupBy<T>(items: T[], keyFn: (item: T) => string): Record<string, T[]> {
+  const result: Record<string, T[]> = {};
+  for (const item of items) {
+    const key = keyFn(item);
+    if (!result[key]) {
+      result[key] = [];
+    }
+    result[key].push(item);
+  }
+  return result;
+}