@evref-bl/dev-nexus 0.1.0-alpha.0

package/dist/workTrackingJiraProvider.js

@@ -0,0 +1,652 @@
+import { Buffer } from "node:buffer";
+import { spawnSync } from "node:child_process";
+export const jiraStatusLabelPrefix = "status:";
+export const jiraRestApiPath = "/rest/api/3";
+const openStatuses = new Set([
+    "todo",
+    "ready",
+    "in_progress",
+    "blocked",
+]);
+const closedStatuses = new Set(["done", "wont_do"]);
+const workStatuses = new Set([
+    ...openStatuses,
+    ...closedStatuses,
+]);
+const jiraIssueFields = [
+    "summary",
+    "description",
+    "status",
+    "labels",
+    "assignee",
+    "created",
+    "updated",
+    "resolutiondate",
+    "issuetype",
+    "project",
+];
+export class JiraWorkTrackerProviderError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "JiraWorkTrackerProviderError";
+    }
+}
+export const jiraWorkTrackerCapabilities = {
+    createItem: true,
+    listItems: true,
+    getItem: true,
+    updateItem: true,
+    comment: true,
+    labels: true,
+    assignees: true,
+    milestones: false,
+    board: false,
+    boardStatus: false,
+    draftItems: false,
+    webhooks: false,
+};
+export function jiraWorkTrackerCapabilitiesForConfig(config) {
+    const hasWorkflowBoard = config.board?.kind === "jira-workflow";
+    return {
+        ...jiraWorkTrackerCapabilities,
+        board: hasWorkflowBoard,
+        boardStatus: hasWorkflowBoard && Object.keys(jiraStatusTransitionOptions(config)).length > 0,
+    };
+}
+export function createJiraWorkTrackerProvider(options) {
+    return new JiraWorkTrackerProvider(options);
+}
+export class JiraWorkTrackerProvider {
+    provider = "jira";
+    capabilities;
+    config;
+    fetchFn;
+    apiBaseUrl;
+    webBaseUrl;
+    staticAuthorizationHeader;
+    credentialRunner;
+    credentialInteractive;
+    credentialAuthorizationHeader;
+    constructor(options) {
+        this.config = options.config;
+        this.fetchFn = options.fetch ?? fetch;
+        this.apiBaseUrl = normalizeJiraApiBaseUrl(options.apiBaseUrl ?? options.config.host);
+        this.webBaseUrl = normalizeJiraWebBaseUrl(options.apiBaseUrl ?? options.config.host);
+        this.capabilities = jiraWorkTrackerCapabilitiesForConfig(options.config);
+        const env = options.env ?? process.env;
+        const token = optionalNonEmptyString(options.token, "token") ??
+            optionalNonEmptyString(env.JIRA_TOKEN, "JIRA_TOKEN");
+        const email = optionalNonEmptyString(options.email, "email") ??
+            optionalNonEmptyString(env.JIRA_EMAIL, "JIRA_EMAIL") ??
+            optionalNonEmptyString(env.ATLASSIAN_EMAIL, "ATLASSIAN_EMAIL");
+        const apiToken = optionalNonEmptyString(options.apiToken, "apiToken") ??
+            optionalNonEmptyString(env.JIRA_API_TOKEN, "JIRA_API_TOKEN") ??
+            optionalNonEmptyString(env.ATLASSIAN_API_TOKEN, "ATLASSIAN_API_TOKEN");
+        this.staticAuthorizationHeader = token
+            ? `Bearer ${token}`
+            : email && apiToken
+                ? basicAuthorizationHeader(email, apiToken)
+                : undefined;
+        this.credentialRunner =
+            options.credentialRunner === false
+                ? undefined
+                : options.credentialRunner ?? defaultJiraCredentialRunner;
+        this.credentialInteractive = options.credentialInteractive ?? false;
+    }
+    async createWorkItem(input) {
+        const status = input.status ?? "todo";
+        assertWorkStatus(status);
+        rejectUnsupportedMilestone(input.milestone);
+        const fields = {
+            project: { key: requiredNonEmptyString(this.config.projectKey, "projectKey") },
+            issuetype: {
+                name: optionalNonEmptyString(this.config.issueType, "issueType") ?? "Task",
+            },
+            summary: requiredNonEmptyString(input.title, "title"),
+            ...(input.description !== undefined
+                ? { description: adfFromPlainText(input.description) }
+                : {}),
+            ...requestLabels(labelsWithStatus(input.labels, status)),
+            ...requestAssignee(input.assignees),
+        };
+        const created = await this.requestJson("POST", "/issue", {
+            fields,
+        });
+        const issueKey = requiredNonEmptyString(created.key ?? created.id, "created.key");
+        await this.applyConfiguredTransition(issueKey, status);
+        return this.getWorkItem({ id: issueKey });
+    }
+    async listWorkItems(query = {}) {
+        const statuses = normalizeStatusFilter(query.status);
+        const limit = normalizeLimit(query.limit);
+        const labels = normalizeStringArray(query.labels, "labels");
+        const assignees = normalizeStringArray(query.assignees, "assignees");
+        const body = {
+            jql: jiraJqlForQuery(this.config.projectKey, labels, assignees),
+            fields: jiraIssueFields,
+            maxResults: limit ? Math.min(Math.max(limit, 1), 100) : 100,
+        };
+        const searchResult = await this.requestJson("POST", "/search/jql", body);
+        const search = query.search?.trim().toLowerCase();
+        const items = (searchResult.issues ?? [])
+            .map((issue) => this.issueToWorkItem(issue))
+            .filter((item) => matchesStatusFilter(item, statuses))
+            .filter((item) => matchesStringFilter(item.labels, labels))
+            .filter((item) => matchesStringFilter(item.assignees, assignees))
+            .filter((item) => !search || matchesSearch(item, search));
+        return limit === undefined ? items : items.slice(0, limit);
+    }
+    async getWorkItem(ref) {
+        return this.issueToWorkItem(await this.getIssue(ref));
+    }
+    async updateWorkItem(ref, patch) {
+        rejectUnsupportedMilestone(patch.milestone);
+        const issueKey = issueKeyFromRef(ref);
+        const fields = {};
+        if (patch.title !== undefined) {
+            fields.summary = requiredNonEmptyString(patch.title, "title");
+        }
+        if (patch.description !== undefined) {
+            fields.description = adfFromPlainText(patch.description);
+        }
+        if (patch.assignees !== undefined) {
+            Object.assign(fields, requestAssignee(patch.assignees));
+        }
+        if (patch.status !== undefined) {
+            assertWorkStatus(patch.status);
+        }
+        if (patch.labels !== undefined || patch.status !== undefined) {
+            const baseLabels = patch.labels !== undefined
+                ? normalizeStringArray(patch.labels, "labels")
+                : labelNames(await this.getIssue(ref));
+            Object.assign(fields, requestLabels(labelsWithStatus(baseLabels, patch.status)));
+        }
+        if (Object.keys(fields).length > 0) {
+            await this.requestJson("PUT", `/issue/${encodePathSegment(issueKey)}`, {
+                fields,
+            });
+        }
+        if (patch.status !== undefined) {
+            await this.applyConfiguredTransition(issueKey, patch.status);
+        }
+        return this.getWorkItem({ id: issueKey });
+    }
+    async addComment(ref, body) {
+        const issueKey = issueKeyFromRef(ref);
+        const comment = await this.requestJson("POST", `/issue/${encodePathSegment(issueKey)}/comment`, {
+            body: adfFromPlainText(requiredNonEmptyString(body, "body")),
+        });
+        return this.commentToWorkComment(comment, issueKey);
+    }
+    async setStatus(ref, status) {
+        return this.updateWorkItem(ref, { status });
+    }
+    async getIssue(ref) {
+        const issueKey = issueKeyFromRef(ref);
+        const params = new URLSearchParams({
+            fields: jiraIssueFields.join(","),
+        });
+        return this.requestJson("GET", `/issue/${encodePathSegment(issueKey)}?${params.toString()}`);
+    }
+    async applyConfiguredTransition(issueKey, status) {
+        const transitionId = jiraStatusTransitionOptions(this.config)[status];
+        if (!transitionId) {
+            return;
+        }
+        await this.requestJson("POST", `/issue/${encodePathSegment(issueKey)}/transitions`, {
+            transition: {
+                id: transitionId,
+            },
+        });
+    }
+    async requestJson(method, pathAndQuery, body) {
+        const url = new URL(pathAndQuery.replace(/^\/+/, ""), `${this.apiBaseUrl}/`);
+        const headers = {
+            Accept: "application/json",
+            "User-Agent": "dev-nexus",
+        };
+        if (body !== undefined) {
+            headers["Content-Type"] = "application/json";
+        }
+        const authorizationHeader = this.authorizationHeader();
+        if (authorizationHeader) {
+            headers.Authorization = authorizationHeader;
+        }
+        const response = await this.fetchFn(url, {
+            method,
+            headers,
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        });
+        if (!response.ok) {
+            const message = await jiraErrorMessage(response, method, url);
+            throw new JiraWorkTrackerProviderError(jiraErrorMessageWithCredentialHint(message, response, authorizationHeader, this.config));
+        }
+        if (response.status === 204) {
+            return undefined;
+        }
+        return (await response.json());
+    }
+    issueToWorkItem(issue) {
+        return {
+            id: `jira-${requiredNonEmptyString(issue.key, "issue.key")}`,
+            title: requiredNonEmptyString(issue.fields.summary, "issue.fields.summary"),
+            description: adfToPlainText(issue.fields.description),
+            status: workStatusFromIssue(issue),
+            provider: "jira",
+            labels: userLabelNames(issue),
+            assignees: assigneeAccountIds(issue),
+            milestone: null,
+            createdAt: issue.fields.created ?? null,
+            updatedAt: issue.fields.updated ?? null,
+            closedAt: issue.fields.resolutiondate ?? null,
+            webUrl: this.issueWebUrl(issue),
+            externalRef: this.issueExternalRef(issue),
+        };
+    }
+    commentToWorkComment(comment, issueKey) {
+        return {
+            id: `jira-comment-${requiredNonEmptyString(comment.id, "comment.id")}`,
+            body: adfToPlainText(comment.body) ?? "",
+            author: comment.author?.displayName ?? comment.author?.accountId ?? null,
+            createdAt: comment.created ?? null,
+            updatedAt: comment.updated ?? null,
+            externalRef: {
+                provider: "jira",
+                host: this.config.host ?? null,
+                projectId: this.config.projectKey,
+                itemId: comment.id,
+                itemKey: issueKey,
+                webUrl: comment.self ?? null,
+            },
+        };
+    }
+    issueExternalRef(issue) {
+        return {
+            provider: "jira",
+            host: this.config.host ?? null,
+            projectId: issue.fields.project?.key ?? this.config.projectKey,
+            itemId: issue.id,
+            itemKey: issue.key,
+            webUrl: this.issueWebUrl(issue),
+        };
+    }
+    issueWebUrl(issue) {
+        return `${this.webBaseUrl}/browse/${encodeURIComponent(issue.key)}`;
+    }
+    authorizationHeader() {
+        if (this.staticAuthorizationHeader) {
+            return this.staticAuthorizationHeader;
+        }
+        if (this.credentialAuthorizationHeader !== undefined) {
+            return this.credentialAuthorizationHeader ?? undefined;
+        }
+        if (!this.credentialRunner) {
+            this.credentialAuthorizationHeader = null;
+            return undefined;
+        }
+        const credential = fillJiraCredential(this.credentialRunner, jiraCredentialRequest(this.config), { interactive: this.credentialInteractive });
+        this.credentialAuthorizationHeader = credential
+            ? authorizationHeaderFromCredential(credential)
+            : null;
+        return this.credentialAuthorizationHeader ?? undefined;
+    }
+}
+export function normalizeJiraApiBaseUrl(hostOrApiBaseUrl) {
+    const url = jiraUrl(hostOrApiBaseUrl);
+    const normalizedPath = url.pathname.replace(/\/+$/, "");
+    if (normalizedPath.endsWith(jiraRestApiPath)) {
+        return `${url.protocol}//${url.host}${normalizedPath}`;
+    }
+    return `${url.protocol}//${url.host}${normalizedPath}${jiraRestApiPath}`;
+}
+export function normalizeJiraWebBaseUrl(hostOrApiBaseUrl) {
+    const url = jiraUrl(hostOrApiBaseUrl);
+    let normalizedPath = url.pathname.replace(/\/+$/, "");
+    if (normalizedPath.endsWith(jiraRestApiPath)) {
+        normalizedPath = normalizedPath.slice(0, -jiraRestApiPath.length);
+    }
+    return `${url.protocol}//${url.host}${normalizedPath}`;
+}
+export function jiraCredentialRequest(config) {
+    return {
+        protocol: "https",
+        host: normalizeJiraCredentialHost(config.host),
+    };
+}
+export function normalizeJiraCredentialHost(hostOrApiBaseUrl) {
+    return jiraUrl(hostOrApiBaseUrl).host;
+}
+export function defaultJiraCredentialRunner(request, options) {
+    const result = spawnSync("git", ["credential", "fill"], {
+        input: jiraCredentialInput(request),
+        encoding: "utf8",
+        env: {
+            ...process.env,
+            ...(options.interactive
+                ? {}
+                : {
+                    GCM_INTERACTIVE: "0",
+                    GIT_TERMINAL_PROMPT: "0",
+                }),
+        },
+    });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+        ...(result.error ? { error: result.error } : {}),
+    };
+}
+function jiraStatusTransitionOptions(config) {
+    const board = config.board;
+    if (!board || board.kind !== "jira-workflow" || !board.statusOptions) {
+        return {};
+    }
+    return board.statusOptions;
+}
+function fillJiraCredential(runner, request, options) {
+    const result = runner(request, options);
+    if (result.status !== 0 || result.error) {
+        return undefined;
+    }
+    const credential = parseJiraCredentialOutput(result.stdout);
+    return credential.authtype && credential.credential
+        ? credential
+        : credential.username && credential.password
+            ? credential
+            : undefined;
+}
+function authorizationHeaderFromCredential(credential) {
+    const authtype = optionalNonEmptyString(credential.authtype, "authtype");
+    const encodedCredential = optionalNonEmptyString(credential.credential, "credential");
+    if (authtype && encodedCredential) {
+        return `${authtype} ${encodedCredential}`;
+    }
+    const username = optionalNonEmptyString(credential.username, "username");
+    const password = optionalNonEmptyString(credential.password, "password");
+    return username && password
+        ? basicAuthorizationHeader(username, password)
+        : undefined;
+}
+function jiraCredentialInput(request) {
+    return [`protocol=${request.protocol}`, `host=${request.host}`, ""].join("\n");
+}
+function parseJiraCredentialOutput(output) {
+    const credential = {};
+    for (const line of output.split(/\r?\n/)) {
+        if (line.length === 0) {
+            continue;
+        }
+        const separator = line.indexOf("=");
+        if (separator <= 0) {
+            continue;
+        }
+        credential[line.slice(0, separator)] = line.slice(separator + 1);
+    }
+    return credential;
+}
+function workStatusFromIssue(issue) {
+    const statusLabel = labelNames(issue).find((label) => label.startsWith(jiraStatusLabelPrefix));
+    if (statusLabel) {
+        const candidate = statusLabel.slice(jiraStatusLabelPrefix.length);
+        if (workStatuses.has(candidate)) {
+            return candidate;
+        }
+    }
+    const statusName = issue.fields.status?.name?.trim().toLowerCase();
+    if (statusName === "ready") {
+        return "ready";
+    }
+    if (statusName === "in progress" || statusName === "in_progress") {
+        return "in_progress";
+    }
+    if (statusName === "blocked") {
+        return "blocked";
+    }
+    if (statusName === "won't do" || statusName === "wont do") {
+        return "wont_do";
+    }
+    const categoryKey = issue.fields.status?.statusCategory?.key;
+    if (categoryKey === "done") {
+        return "done";
+    }
+    if (categoryKey === "indeterminate") {
+        return "in_progress";
+    }
+    return "todo";
+}
+function labelsWithStatus(labels, status) {
+    const normalized = normalizeStringArray(labels, "labels").filter((label) => !label.startsWith(jiraStatusLabelPrefix));
+    if (status && status !== "todo") {
+        normalized.push(`${jiraStatusLabelPrefix}${status}`);
+    }
+    return dedupeStrings(normalized);
+}
+function userLabelNames(issue) {
+    return labelNames(issue).filter((label) => !label.startsWith(jiraStatusLabelPrefix));
+}
+function labelNames(issue) {
+    return (issue.fields.labels ?? [])
+        .filter((label) => Boolean(label && label.trim()))
+        .map((label) => label.trim());
+}
+function assigneeAccountIds(issue) {
+    const accountId = issue.fields.assignee?.accountId?.trim();
+    return accountId ? [accountId] : [];
+}
+function issueKeyFromRef(ref) {
+    if (ref.provider && ref.provider !== "jira") {
+        throw new JiraWorkTrackerProviderError(`jira provider cannot resolve ${ref.provider} work item refs`);
+    }
+    if (ref.externalRef?.provider && ref.externalRef.provider !== "jira") {
+        throw new JiraWorkTrackerProviderError(`jira provider cannot resolve ${ref.externalRef.provider} external refs`);
+    }
+    const candidate = ref.externalRef?.itemKey ?? ref.id ?? ref.externalRef?.itemId;
+    if (candidate === undefined || candidate === null) {
+        throw new JiraWorkTrackerProviderError("Jira issue key or id is required");
+    }
+    return requiredNonEmptyString(String(candidate), "issue key").replace(/^jira-/, "");
+}
+function normalizeStatusFilter(status) {
+    if (status === undefined) {
+        return undefined;
+    }
+    const values = Array.isArray(status) ? status : [status];
+    const normalized = new Set();
+    for (const value of values) {
+        assertWorkStatus(value);
+        normalized.add(value);
+    }
+    return normalized;
+}
+function matchesStatusFilter(item, statuses) {
+    return !statuses || statuses.size === 0 || statuses.has(item.status);
+}
+function matchesStringFilter(itemValues, requiredValues) {
+    return requiredValues.every((value) => itemValues?.includes(value));
+}
+function matchesSearch(item, search) {
+    return [
+        item.id,
+        item.externalRef?.itemKey ?? "",
+        item.title,
+        item.description ?? "",
+    ].some((value) => value.toLowerCase().includes(search));
+}
+function requestLabels(labels) {
+    return labels.length > 0 ? { labels } : {};
+}
+function requestAssignee(assignees) {
+    if (assignees === undefined) {
+        return {};
+    }
+    const normalized = normalizeStringArray(assignees, "assignees");
+    if (normalized.length > 1) {
+        throw new JiraWorkTrackerProviderError("Jira supports only one assignee account id per issue");
+    }
+    return {
+        assignee: normalized.length === 0 ? null : { accountId: normalized[0] },
+    };
+}
+function jiraJqlForQuery(projectKey, labels, assignees) {
+    const clauses = [`project = ${jqlString(projectKey)}`];
+    if (labels.length > 0) {
+        clauses.push(`labels in (${labels.map(jqlString).join(", ")})`);
+    }
+    if (assignees.length > 0) {
+        clauses.push(`assignee in (${assignees.map(jqlString).join(", ")})`);
+    }
+    return `${clauses.join(" AND ")} ORDER BY updated DESC`;
+}
+function jqlString(value) {
+    return `"${requiredNonEmptyString(value, "jql value").replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function adfFromPlainText(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    const lines = value.split(/\r?\n/);
+    return {
+        type: "doc",
+        version: 1,
+        content: (lines.length > 0 ? lines : [""]).map((line) => ({
+            type: "paragraph",
+            ...(line.length > 0
+                ? {
+                    content: [
+                        {
+                            type: "text",
+                            text: line,
+                        },
+                    ],
+                }
+                : {}),
+        })),
+    };
+}
+function adfToPlainText(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    return value.content.map(adfNodeText).join("\n");
+}
+function adfNodeText(node) {
+    if (typeof node.text === "string") {
+        return node.text;
+    }
+    if (node.type === "hardBreak") {
+        return "\n";
+    }
+    if (!node.content) {
+        return "";
+    }
+    return node.content.map(adfNodeText).join("");
+}
+function normalizeLimit(limit) {
+    if (limit === undefined) {
+        return undefined;
+    }
+    if (!Number.isInteger(limit) || limit < 0) {
+        throw new JiraWorkTrackerProviderError("limit must be a non-negative integer");
+    }
+    return limit;
+}
+function normalizeStringArray(values, pathName) {
+    if (values === undefined) {
+        return [];
+    }
+    if (!Array.isArray(values)) {
+        throw new JiraWorkTrackerProviderError(`${pathName} must be an array`);
+    }
+    return dedupeStrings(values.map((value, index) => requiredNonEmptyString(value, `${pathName}[${index}]`)));
+}
+function dedupeStrings(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (!seen.has(value)) {
+            seen.add(value);
+            result.push(value);
+        }
+    }
+    return result;
+}
+function assertWorkStatus(status) {
+    if (!workStatuses.has(status)) {
+        throw new JiraWorkTrackerProviderError(`Invalid work status: ${status}`);
+    }
+}
+function rejectUnsupportedMilestone(value) {
+    if (value !== undefined && value !== null) {
+        throw new JiraWorkTrackerProviderError("Jira milestone mapping is not configured; use Jira labels or issue fields directly");
+    }
+}
+function requiredNonEmptyString(value, pathName) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new JiraWorkTrackerProviderError(`${pathName} must be a non-empty string`);
+    }
+    return value.trim();
+}
+function optionalNonEmptyString(value, pathName) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (value.trim().length === 0) {
+        return undefined;
+    }
+    return requiredNonEmptyString(value, pathName);
+}
+function encodePathSegment(value) {
+    return encodeURIComponent(requiredNonEmptyString(value, "path segment"));
+}
+function jiraUrl(hostOrApiBaseUrl) {
+    const value = optionalNonEmptyString(hostOrApiBaseUrl, "host");
+    if (!value) {
+        throw new JiraWorkTrackerProviderError("Jira provider requires a host or apiBaseUrl");
+    }
+    return value.startsWith("http://") || value.startsWith("https://")
+        ? new URL(value)
+        : new URL(`https://${value}`);
+}
+function basicAuthorizationHeader(username, password) {
+    return `Basic ${Buffer.from(`${username}:${password}`, "utf8").toString("base64")}`;
+}
+async function jiraErrorMessage(response, method, url) {
+    let detail;
+    try {
+        const body = (await response.json());
+        detail = jiraErrorDetail(body);
+    }
+    catch {
+        detail = await response.text().catch(() => undefined);
+    }
+    return [
+        `Jira request failed: ${method} ${url.pathname} returned ${response.status}`,
+        detail ? `: ${detail}` : "",
+    ].join("");
+}
+function jiraErrorDetail(body) {
+    if (body.message) {
+        return body.message;
+    }
+    if (body.errorMessages?.length) {
+        return body.errorMessages.join("; ");
+    }
+    if (body.errors && Object.keys(body.errors).length > 0) {
+        return JSON.stringify(body.errors);
+    }
+    return undefined;
+}
+function jiraErrorMessageWithCredentialHint(message, response, authorizationHeader, config) {
+    if (authorizationHeader ||
+        (response.status !== 401 && response.status !== 403)) {
+        return message;
+    }
+    return (`${message}. No Jira token, API token, or git credential was available ` +
+        `for ${normalizeJiraCredentialHost(config.host)}. Configure JIRA_TOKEN, ` +
+        "JIRA_EMAIL with JIRA_API_TOKEN, ATLASSIAN_EMAIL with " +
+        "ATLASSIAN_API_TOKEN, or a git credential helper.");
+}

package/dist/workTrackingLocalProvider.d.ts

@@ -0,0 +1,49 @@
+import type { CreateWorkItemInput, DetectedTracker, DetectTrackerInput, LocalWorkTrackingConfig, NexusProjectContext, TrackerCapabilities, TrackerProjectRef, WorkComment, WorkItem, WorkItemPatch, WorkItemQuery, WorkItemRef, WorkStatus, WorkTrackerProvider } from "./workTrackingTypes.js";
+export declare const localWorkTrackingDirectoryName = ".dev-nexus";
+export declare const localWorkTrackingStoreFileName = "work-items.json";
+export declare const localWorkTrackingStoreVersion = 1;
+export interface LocalWorkTrackingStore {
+    version: typeof localWorkTrackingStoreVersion;
+    nextNumber: number;
+    nextCommentNumber: number;
+    updatedAt: string;
+    items: WorkItem[];
+    comments: Record<string, WorkComment[]>;
+}
+export interface LocalWorkTrackerProviderOptions {
+    projectRoot?: string;
+    config?: LocalWorkTrackingConfig;
+    storePath?: string | null;
+    now?: () => Date | string;
+}
+export declare class LocalWorkTrackerProviderError extends Error {
+    constructor(message: string);
+}
+export declare const localWorkTrackerCapabilities: TrackerCapabilities;
+export declare function defaultLocalWorkTrackingStorePath(projectRoot: string): string;
+export declare function resolveLocalWorkTrackingStorePath(projectRoot: string, config?: Pick<LocalWorkTrackingConfig, "storePath"> | string | null): string;
+export declare function createLocalWorkTrackerProvider(options?: LocalWorkTrackerProviderOptions): LocalWorkTrackerProvider;
+export declare class LocalWorkTrackerProvider implements WorkTrackerProvider {
+    readonly provider = "local";
+    readonly capabilities: TrackerCapabilities;
+    private readonly projectRoot?;
+    private readonly config?;
+    private readonly storePath?;
+    private readonly nowProvider;
+    constructor(options?: LocalWorkTrackerProviderOptions);
+    detect(input: DetectTrackerInput): Promise<DetectedTracker | undefined>;
+    ensureProject(context: NexusProjectContext): Promise<TrackerProjectRef>;
+    createWorkItem(input: CreateWorkItemInput): Promise<WorkItem>;
+    listWorkItems(query?: WorkItemQuery): Promise<WorkItem[]>;
+    getWorkItem(ref: WorkItemRef): Promise<WorkItem>;
+    updateWorkItem(ref: WorkItemRef, patch: WorkItemPatch): Promise<WorkItem>;
+    addComment(ref: WorkItemRef, body: string): Promise<WorkComment>;
+    setStatus(ref: WorkItemRef, status: WorkStatus): Promise<WorkItem>;
+    private resolveProjectRoot;
+    private storePathFor;
+    private loadStore;
+    private saveStore;
+    private now;
+}
+export declare function loadLocalWorkTrackingStore(storePath: string, timestamp?: string): LocalWorkTrackingStore;
+export declare function saveLocalWorkTrackingStore(storePath: string, store: LocalWorkTrackingStore): void;