@gh-symphony/cli 0.0.1 → 0.0.2

package/dist/config.js

@@ -11,14 +11,14 @@ export function resolveConfigDir(override) {
 export function configFilePath(configDir) {
     return join(configDir, CONFIG_FILE);
 }
-export function workspaceConfigDir(configDir, workspaceId) {
-    return join(configDir, "workspaces", workspaceId);
+export function tenantConfigDir(configDir, tenantId) {
+    return join(configDir, "tenants", tenantId);
 }
-export function workspaceConfigPath(configDir, workspaceId) {
-    return join(workspaceConfigDir(configDir, workspaceId), "workspace.json");
+export function tenantConfigPath(configDir, tenantId) {
+    return join(tenantConfigDir(configDir, tenantId), "tenant.json");
 }
-export function workflowMappingPath(configDir, workspaceId) {
-    return join(workspaceConfigDir(configDir, workspaceId), "workflow-mapping.json");
+export function workflowMappingPath(configDir, tenantId) {
+    return join(tenantConfigDir(configDir, tenantId), "workflow-mapping.json");
 }
 export function daemonPidPath(configDir) {
     return join(configDir, DAEMON_PID_FILE);
@@ -35,24 +35,24 @@ export async function loadGlobalConfig(configDir) {
 export async function saveGlobalConfig(configDir, config) {
     await writeJsonFile(configFilePath(configDir), config);
 }
-export async function loadWorkspaceConfig(configDir, workspaceId) {
-    return readJsonFile(workspaceConfigPath(configDir, workspaceId));
+export async function loadTenantConfig(configDir, tenantId) {
+    return readJsonFile(tenantConfigPath(configDir, tenantId));
 }
-export async function saveWorkspaceConfig(configDir, workspaceId, config) {
-    await writeJsonFile(workspaceConfigPath(configDir, workspaceId), config);
+export async function saveTenantConfig(configDir, tenantId, config) {
+    await writeJsonFile(tenantConfigPath(configDir, tenantId), config);
 }
-export async function loadWorkflowMapping(configDir, workspaceId) {
-    return readJsonFile(workflowMappingPath(configDir, workspaceId));
+export async function loadWorkflowMapping(configDir, tenantId) {
+    return readJsonFile(workflowMappingPath(configDir, tenantId));
 }
-export async function saveWorkflowMapping(configDir, workspaceId, mapping) {
-    await writeJsonFile(workflowMappingPath(configDir, workspaceId), mapping);
+export async function saveWorkflowMapping(configDir, tenantId, mapping) {
+    await writeJsonFile(workflowMappingPath(configDir, tenantId), mapping);
 }
-export async function loadActiveWorkspaceConfig(configDir) {
+export async function loadActiveTenantConfig(configDir) {
     const global = await loadGlobalConfig(configDir);
-    if (!global?.activeWorkspace) {
+    if (!global?.activeTenant) {
         return null;
     }
-    return loadWorkspaceConfig(configDir, global.activeWorkspace);
+    return loadTenantConfig(configDir, global.activeTenant);
 }
 async function readJsonFile(path) {
     try {

package/dist/context/context-types.d.ts

@@ -0,0 +1,36 @@
+import type { DetectedEnvironment } from "../detection/environment-detector.js";
+export type ContextYaml = {
+    schema_version: 1;
+    collected_at: string;
+    project: {
+        id: string;
+        title: string;
+        url: string;
+    };
+    status_field: {
+        id: string;
+        name: string;
+        columns: Array<{
+            id: string;
+            name: string;
+            color: string | null;
+            inferred_role: "active" | "wait" | "terminal" | null;
+            confidence: "high" | "low";
+        }>;
+    };
+    text_fields: Array<{
+        id: string;
+        name: string;
+        data_type: string;
+    }>;
+    repositories: Array<{
+        owner: string;
+        name: string;
+        clone_url: string;
+    }>;
+    detected_environment: DetectedEnvironment;
+    runtime: {
+        agent: string;
+        agent_command: string;
+    };
+};

package/dist/context/context-types.js

@@ -0,0 +1 @@
+export {};

package/dist/context/generate-context-yaml.d.ts

@@ -0,0 +1,15 @@
+import type { ProjectDetail, ProjectStatusField } from "../github/client.js";
+import type { DetectedEnvironment } from "../detection/environment-detector.js";
+import type { ContextYaml } from "./context-types.js";
+export type BuildContextYamlParams = {
+    projectDetail: ProjectDetail;
+    statusField: ProjectStatusField;
+    detectedEnvironment: DetectedEnvironment;
+    runtime: {
+        agent: string;
+        agent_command: string;
+    };
+};
+export declare function generateContextYamlString(context: ContextYaml): string;
+export declare function writeContextYaml(outputDir: string, context: ContextYaml): Promise<void>;
+export declare function buildContextYaml(params: BuildContextYamlParams): ContextYaml;

package/dist/context/generate-context-yaml.js

@@ -0,0 +1,129 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { inferStateRole } from "../mapping/smart-defaults.js";
+function yamlQuote(value) {
+    const specialChars = /[:#{'"\]{}()\\[]|\n/;
+    if (specialChars.test(value)) {
+        return `"${value.replace(/"/g, '\\"')}"`;
+    }
+    return value;
+}
+export function generateContextYamlString(context) {
+    const lines = [];
+    lines.push("schema_version: 1");
+    lines.push(`collected_at: ${context.collected_at}`);
+    lines.push("");
+    lines.push("project:");
+    lines.push(`  id: ${context.project.id}`);
+    lines.push(`  title: ${yamlQuote(context.project.title)}`);
+    lines.push(`  url: ${context.project.url}`);
+    lines.push("");
+    lines.push("status_field:");
+    lines.push(`  id: ${context.status_field.id}`);
+    lines.push(`  name: ${yamlQuote(context.status_field.name)}`);
+    lines.push("  columns:");
+    for (const column of context.status_field.columns) {
+        lines.push(`    - id: ${column.id}`);
+        lines.push(`      name: ${yamlQuote(column.name)}`);
+        lines.push(`      color: ${column.color === null ? "null" : yamlQuote(column.color)}`);
+        lines.push(`      inferred_role: ${column.inferred_role === null ? "null" : column.inferred_role}`);
+        lines.push(`      confidence: ${column.confidence}`);
+    }
+    lines.push("");
+    lines.push("text_fields:");
+    if (context.text_fields.length === 0) {
+        lines.push("  []");
+    }
+    else {
+        for (const field of context.text_fields) {
+            lines.push(`  - id: ${field.id}`);
+            lines.push(`    name: ${yamlQuote(field.name)}`);
+            lines.push(`    data_type: ${field.data_type}`);
+        }
+    }
+    lines.push("");
+    lines.push("repositories:");
+    if (context.repositories.length === 0) {
+        lines.push("  []");
+    }
+    else {
+        for (const repo of context.repositories) {
+            lines.push(`  - owner: ${repo.owner}`);
+            lines.push(`    name: ${repo.name}`);
+            lines.push(`    clone_url: ${repo.clone_url}`);
+        }
+    }
+    lines.push("");
+    lines.push("detected_environment:");
+    lines.push(`  packageManager: ${context.detected_environment.packageManager === null ? "null" : yamlQuote(context.detected_environment.packageManager)}`);
+    lines.push(`  lockfile: ${context.detected_environment.lockfile === null ? "null" : yamlQuote(context.detected_environment.lockfile)}`);
+    lines.push(`  testCommand: ${context.detected_environment.testCommand === null ? "null" : yamlQuote(context.detected_environment.testCommand)}`);
+    lines.push(`  buildCommand: ${context.detected_environment.buildCommand === null ? "null" : yamlQuote(context.detected_environment.buildCommand)}`);
+    lines.push(`  lintCommand: ${context.detected_environment.lintCommand === null ? "null" : yamlQuote(context.detected_environment.lintCommand)}`);
+    lines.push(`  ciPlatform: ${context.detected_environment.ciPlatform === null ? "null" : yamlQuote(context.detected_environment.ciPlatform)}`);
+    lines.push(`  monorepo: ${context.detected_environment.monorepo}`);
+    lines.push("  existingSkills:");
+    if (context.detected_environment.existingSkills.length === 0) {
+        lines.push("    []");
+    }
+    else {
+        for (const skill of context.detected_environment.existingSkills) {
+            lines.push(`    - ${yamlQuote(skill)}`);
+        }
+    }
+    lines.push("");
+    lines.push("runtime:");
+    lines.push(`  agent: ${yamlQuote(context.runtime.agent)}`);
+    lines.push(`  agent_command: ${yamlQuote(context.runtime.agent_command)}`);
+    return lines.join("\n") + "\n";
+}
+export async function writeContextYaml(outputDir, context) {
+    await mkdir(outputDir, { recursive: true });
+    const contextPath = `${outputDir}/.gh-symphony/context.yaml`;
+    await mkdir(dirname(contextPath), { recursive: true });
+    const temporaryPath = `${contextPath}.tmp`;
+    const yamlContent = generateContextYamlString(context);
+    await writeFile(temporaryPath, yamlContent, "utf8");
+    const { rename } = await import("node:fs/promises");
+    await rename(temporaryPath, contextPath);
+}
+export function buildContextYaml(params) {
+    const columns = params.statusField.options.map((option) => {
+        const roleMapping = inferStateRole(option.name);
+        return {
+            id: option.id,
+            name: option.name,
+            color: option.color,
+            inferred_role: roleMapping.role,
+            confidence: roleMapping.confidence,
+        };
+    });
+    const textFields = params.projectDetail.textFields.map((field) => ({
+        id: field.id,
+        name: field.name,
+        data_type: field.dataType,
+    }));
+    const repositories = params.projectDetail.linkedRepositories.map((repo) => ({
+        owner: repo.owner,
+        name: repo.name,
+        clone_url: repo.cloneUrl,
+    }));
+    return {
+        schema_version: 1,
+        collected_at: new Date().toISOString(),
+        project: {
+            id: params.projectDetail.id,
+            title: params.projectDetail.title,
+            url: params.projectDetail.url,
+        },
+        status_field: {
+            id: params.statusField.id,
+            name: params.statusField.name,
+            columns,
+        },
+        text_fields: textFields,
+        repositories,
+        detected_environment: params.detectedEnvironment,
+        runtime: params.runtime,
+    };
+}

package/dist/dashboard/renderer.d.ts

@@ -0,0 +1,9 @@
+import type { TenantStatusSnapshot } from "@gh-symphony/core";
+export type DashboardOptions = {
+    terminalWidth: number;
+    noColor: boolean;
+    maxAgents?: number;
+    /** Override Date.now() for deterministic testing */
+    now?: number;
+};
+export declare function renderDashboard(snapshots: TenantStatusSnapshot[], options: DashboardOptions): string;

package/dist/dashboard/renderer.js

@@ -0,0 +1,220 @@
+// ── Dashboard Renderer (Elixir-parity) ──────────────────────────────────────
+import { bold, dim, green, red, yellow, cyan, magenta, blue, stripAnsi, } from "../ansi.js";
+// ── Column widths (from Elixir spec) ─────────────────────────────────────────
+const COL_ID = 8;
+const COL_STAGE = 14;
+const COL_PID = 8;
+const COL_AGE_TURN = 12;
+const COL_TOKENS = 10;
+const COL_SESSION = 14;
+/** ID header width accounts for "● " prefix in data rows */
+const COL_ID_HEADER = COL_ID + 2;
+// ── Helpers ──────────────────────────────────────────────────────────────────
+const identity = (s) => s;
+function makeColors(noColor) {
+    if (noColor) {
+        return {
+            bold: identity,
+            dim: identity,
+            green: identity,
+            red: identity,
+            yellow: identity,
+            cyan: identity,
+            magenta: identity,
+            blue: identity,
+        };
+    }
+    return { bold, dim, green, red, yellow, cyan, magenta, blue };
+}
+function pad(s, width, align = "left") {
+    const visible = stripAnsi(s);
+    if (visible.length >= width)
+        return visible.slice(0, width);
+    const padding = " ".repeat(width - visible.length);
+    return align === "right" ? padding + s : s + padding;
+}
+function compactSessionId(id) {
+    if (!id)
+        return "\u2014";
+    if (id.length <= 10)
+        return id;
+    return `${id.slice(0, 4)}...${id.slice(-6)}`;
+}
+function fmtTokens(n) {
+    return n.toLocaleString("en-US");
+}
+function fmtAge(startedAt, now) {
+    if (!startedAt)
+        return "0m";
+    const diffMs = now - new Date(startedAt).getTime();
+    if (diffMs < 0)
+        return "0m";
+    const totalMin = Math.floor(diffMs / 60_000);
+    if (totalMin < 60)
+        return `${totalMin}m`;
+    const h = Math.floor(totalMin / 60);
+    const m = totalMin % 60;
+    return `${h}h ${m}m`;
+}
+function fmtRuntime(ms) {
+    if (ms <= 0)
+        return "0h 0m";
+    const totalMin = Math.floor(ms / 60_000);
+    const h = Math.floor(totalMin / 60);
+    const m = totalMin % 60;
+    return `${h}h ${m}m`;
+}
+function fmtRetryTime(nextRetryAt, now) {
+    if (!nextRetryAt)
+        return "\u2014";
+    const diffMs = new Date(nextRetryAt).getTime() - now;
+    if (diffMs <= 0)
+        return "now";
+    const totalSec = Math.ceil(diffMs / 1000);
+    if (totalSec < 60)
+        return `${totalSec}s`;
+    const m = Math.floor(totalSec / 60);
+    const s = totalSec % 60;
+    return s > 0 ? `${m}m ${s}s` : `${m}m`;
+}
+const COL_SEPARATORS = 6;
+function eventColWidth(termWidth) {
+    const fixed = 2 +
+        COL_ID_HEADER +
+        COL_STAGE +
+        COL_PID +
+        COL_AGE_TURN +
+        COL_TOKENS +
+        COL_SESSION +
+        COL_SEPARATORS;
+    return Math.max(5, termWidth - fixed);
+}
+// ── Status dot ───────────────────────────────────────────────────────────────
+function statusDot(run, c) {
+    const event = run.lastEvent;
+    if (event === null || event === undefined || run.status === "failed")
+        return c.red("\u25CF");
+    if (event === "token_count")
+        return c.yellow("\u25CF");
+    if (event === "task_started")
+        return c.green("\u25CF");
+    if (event === "turn_completed")
+        return c.magenta("\u25CF");
+    return c.blue("\u25CF");
+}
+// ── Section builders ─────────────────────────────────────────────────────────
+function titleBar(width, c) {
+    const title = " gh-symphony ";
+    const side = Math.max(0, Math.floor((width - title.length) / 2));
+    const right = Math.max(0, width - side - title.length);
+    return c.bold("\u2550".repeat(side) + title + "\u2550".repeat(right));
+}
+function sectionDivider(label, width, c) {
+    const prefix = `\u2500\u2500 ${label} `;
+    const fill = "\u2500".repeat(Math.max(0, width - prefix.length));
+    return c.dim(prefix + fill);
+}
+function buildSummaryLines(snapshots, options, c) {
+    const now = options.now ?? Date.now();
+    const lines = [];
+    const totalActive = snapshots.reduce((sum, s) => sum + s.summary.activeRuns, 0);
+    const agentStr = options.maxAgents != null
+        ? `${totalActive}/${options.maxAgents}`
+        : `${totalActive}`;
+    const totIn = snapshots.reduce((sum, s) => sum + (s.codexTotals?.inputTokens ?? 0), 0);
+    const totOut = snapshots.reduce((sum, s) => sum + (s.codexTotals?.outputTokens ?? 0), 0);
+    const totAll = snapshots.reduce((sum, s) => sum + (s.codexTotals?.totalTokens ?? 0), 0);
+    const allStarts = snapshots
+        .flatMap((s) => s.activeRuns)
+        .map((r) => r.startedAt)
+        .filter((t) => t != null)
+        .map((t) => new Date(t).getTime());
+    const runtimeMs = allStarts.length > 0 ? now - Math.min(...allStarts) : 0;
+    const runtime = fmtRuntime(runtimeMs);
+    lines.push(`  ${c.dim("Agents")}  ${c.bold(agentStr)}     ${c.dim("Runtime")}  ${c.bold(runtime)}    ${c.dim("Tokens")}  ${fmtTokens(totIn)} in / ${fmtTokens(totOut)} out / ${c.bold(fmtTokens(totAll))} total`);
+    const hasLimits = snapshots.some((s) => s.rateLimits != null);
+    const limitStr = hasLimits ? "active" : "standard";
+    lines.push(`  ${c.dim("Rate Limits")}  ${limitStr}`);
+    return lines;
+}
+function tableHeaderRow(c) {
+    const cols = [
+        pad("ID", COL_ID_HEADER),
+        pad("STAGE", COL_STAGE),
+        pad("PID", COL_PID),
+        pad("AGE/TURN", COL_AGE_TURN),
+        pad("TOKENS", COL_TOKENS),
+        pad("SESSION", COL_SESSION),
+        "EVENT",
+    ].join(" ");
+    return `  ${c.dim(cols)}`;
+}
+function activeRunRow(run, now, evtWidth, c) {
+    const dot = statusDot(run, c);
+    const id = pad(run.issueIdentifier, COL_ID);
+    const stage = pad(run.issueState, COL_STAGE);
+    const pid = pad(run.processId != null ? String(run.processId) : "\u2014", COL_PID);
+    const age = fmtAge(run.startedAt, now);
+    const turn = run.turnCount ?? 0;
+    const ageTurn = pad(`${age}/${turn}`, COL_AGE_TURN);
+    const tokens = pad(fmtTokens(run.tokenUsage?.totalTokens ?? 0), COL_TOKENS, "right");
+    const sessionId = run.runtimeSession?.sessionId ?? run.runtimeSession?.threadId ?? null;
+    const session = pad(compactSessionId(sessionId), COL_SESSION);
+    const event = pad(run.lastEvent ?? "\u2014", evtWidth);
+    const columns = [id, stage, pid, ageTurn, tokens, session, event].join(" ");
+    return `  ${dot} ${columns}`;
+}
+function retryRow(entry, snapshot, now, c) {
+    const id = entry.issueIdentifier;
+    const kind = entry.retryKind;
+    const timeStr = fmtRetryTime(entry.nextRetryAt, now);
+    const matchingRun = snapshot.activeRuns.find((r) => r.runId === entry.runId);
+    const errorHint = matchingRun?.lastEvent ?? "";
+    return `  ${c.yellow("\u21BB")} ${id}  ${kind}  retrying in ${timeStr}${errorHint ? "  " + errorHint : ""}`;
+}
+// ── Main Renderer ────────────────────────────────────────────────────────────
+export function renderDashboard(snapshots, options) {
+    const width = options.terminalWidth || 115;
+    const now = options.now ?? Date.now();
+    const c = makeColors(options.noColor);
+    const evtWidth = eventColWidth(width);
+    const lines = [];
+    lines.push(titleBar(width, c));
+    lines.push(...buildSummaryLines(snapshots, options, c));
+    lines.push("");
+    for (const snap of snapshots) {
+        const hasActiveRuns = snap.activeRuns.length > 0;
+        const hasRetries = snap.retryQueue.length > 0;
+        if (!hasActiveRuns && !hasRetries)
+            continue;
+        lines.push(sectionDivider(snap.slug, width, c));
+        if (hasActiveRuns) {
+            lines.push(tableHeaderRow(c));
+            for (const rawRun of snap.activeRuns) {
+                const run = rawRun;
+                lines.push(activeRunRow(run, now, evtWidth, c));
+            }
+        }
+        lines.push("");
+    }
+    const allRetries = [];
+    for (const snap of snapshots) {
+        for (const entry of snap.retryQueue) {
+            allRetries.push({ entry, snapshot: snap });
+        }
+    }
+    if (allRetries.length > 0) {
+        lines.push(sectionDivider("Backoff Queue", width, c));
+        for (const { entry, snapshot } of allRetries) {
+            lines.push(retryRow(entry, snapshot, now, c));
+        }
+        lines.push("");
+    }
+    const result = lines.map((line) => {
+        const visible = stripAnsi(line);
+        if (visible.length <= width)
+            return line;
+        return visible.slice(0, width);
+    });
+    return result.join("\n");
+}

package/dist/detection/environment-detector.d.ts

@@ -0,0 +1,11 @@
+export type DetectedEnvironment = {
+    packageManager: "pnpm" | "npm" | "yarn" | "bun" | null;
+    lockfile: string | null;
+    testCommand: string | null;
+    buildCommand: string | null;
+    lintCommand: string | null;
+    ciPlatform: "github-actions" | null;
+    monorepo: boolean;
+    existingSkills: string[];
+};
+export declare function detectEnvironment(cwd: string): Promise<DetectedEnvironment>;

package/dist/detection/environment-detector.js

@@ -0,0 +1,140 @@
+import { access, readFile } from "node:fs/promises";
+import { join } from "node:path";
+function isFileMissing(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch (error) {
+        if (isFileMissing(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function readJsonFile(path) {
+    try {
+        const raw = await readFile(path, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (isFileMissing(error)) {
+            return null;
+        }
+        if (error instanceof SyntaxError) {
+            return null;
+        }
+        throw error;
+    }
+}
+async function detectPackageManager(cwd) {
+    const lockfiles = [
+        { name: "pnpm-lock.yaml", manager: "pnpm" },
+        { name: "bun.lock", manager: "bun" },
+        { name: "bun.lockb", manager: "bun" },
+        { name: "yarn.lock", manager: "yarn" },
+        { name: "package-lock.json", manager: "npm" },
+    ];
+    for (const { name, manager } of lockfiles) {
+        const exists = await fileExists(join(cwd, name));
+        if (exists) {
+            return { packageManager: manager, lockfile: name };
+        }
+    }
+    return { packageManager: null, lockfile: null };
+}
+async function detectScripts(cwd) {
+    const packageJson = await readJsonFile(join(cwd, "package.json"));
+    if (!packageJson?.scripts) {
+        return { testCommand: null, buildCommand: null, lintCommand: null };
+    }
+    return {
+        testCommand: packageJson.scripts.test ?? null,
+        buildCommand: packageJson.scripts.build ?? null,
+        lintCommand: packageJson.scripts.lint ?? null,
+    };
+}
+async function detectCiPlatform(cwd) {
+    const workflowsDir = join(cwd, ".github", "workflows");
+    const exists = await fileExists(workflowsDir);
+    return exists ? "github-actions" : null;
+}
+async function detectMonorepo(cwd) {
+    // Check for pnpm-workspace.yaml
+    const hasPnpmWorkspace = await fileExists(join(cwd, "pnpm-workspace.yaml"));
+    if (hasPnpmWorkspace) {
+        return true;
+    }
+    // Check for lerna.json
+    const hasLerna = await fileExists(join(cwd, "lerna.json"));
+    if (hasLerna) {
+        return true;
+    }
+    // Check for workspaces field in package.json
+    const packageJson = await readJsonFile(join(cwd, "package.json"));
+    if (packageJson?.workspaces) {
+        return true;
+    }
+    return false;
+}
+async function detectExistingSkills(cwd) {
+    const skills = [];
+    // Check .claude/skills/
+    const claudeSkillsDir = join(cwd, ".claude", "skills");
+    try {
+        const { readdirSync } = await import("node:fs");
+        const entries = readdirSync(claudeSkillsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                skills.push(entry.name);
+            }
+        }
+    }
+    catch (error) {
+        if (!isFileMissing(error)) {
+            throw error;
+        }
+    }
+    // Check .codex/skills/
+    const codexSkillsDir = join(cwd, ".codex", "skills");
+    try {
+        const { readdirSync } = await import("node:fs");
+        const entries = readdirSync(codexSkillsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                skills.push(entry.name);
+            }
+        }
+    }
+    catch (error) {
+        if (!isFileMissing(error)) {
+            throw error;
+        }
+    }
+    return skills;
+}
+export async function detectEnvironment(cwd) {
+    const [{ packageManager, lockfile }, { testCommand, buildCommand, lintCommand }, ciPlatform, monorepo, existingSkills,] = await Promise.all([
+        detectPackageManager(cwd),
+        detectScripts(cwd),
+        detectCiPlatform(cwd),
+        detectMonorepo(cwd),
+        detectExistingSkills(cwd),
+    ]);
+    return {
+        packageManager,
+        lockfile,
+        testCommand,
+        buildCommand,
+        lintCommand,
+        ciPlatform,
+        monorepo,
+        existingSkills,
+    };
+}

package/dist/github/client.d.ts

@@ -36,17 +36,28 @@ export type LinkedRepository = {
     url: string;
     cloneUrl: string;
 };
+export type ProjectTextField = {
+    id: string;
+    name: string;
+    dataType: string;
+};
 export type ProjectDetail = {
     id: string;
     title: string;
     url: string;
     statusFields: ProjectStatusField[];
+    textFields: ProjectTextField[];
     linkedRepositories: LinkedRepository[];
 };
 export declare class GitHubApiError extends Error {
     readonly status?: number | undefined;
     constructor(message: string, status?: number | undefined);
 }
+export declare class GitHubScopeError extends GitHubApiError {
+    readonly requiredScopes: string[];
+    readonly currentScopes: string[];
+    constructor(message: string, requiredScopes: string[], currentScopes: string[]);
+}
 export declare function createClient(token: string, options?: {
     apiUrl?: string;
     fetchImpl?: typeof fetch;