@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/issues/cli.js

@@ -0,0 +1,327 @@
+/**
+ * Local issue CLI — `aiwg issue <subcommand>`
+ *
+ * This command operates on local issue storage under `.aiwg/issues/`. It can
+ * also import/export snapshots and opt into live Gitea/GitHub API sync for
+ * local issue migration workflows.
+ *
+ * @issue #1462
+ */
+import { readFile, writeFile } from 'fs/promises';
+import { LocalIssueProviderCore, buildExternalIssueSnapshotFromLocal, buildLocalIssueConflictReport, createLiveIssueClient, localIssueRoot, parseCommentIdMappings, parseExternalIssueSnapshot, } from './index.js';
+export async function main(args, cwd = process.cwd()) {
+    const parsed = parseArgs(args);
+    const subcommand = parsed.positional[0];
+    const rest = parsed.positional.slice(1);
+    if (parsed.flags.has('backend')) {
+        throw new Error('aiwg issue commands use the local issue provider; --backend is not supported');
+    }
+    const provider = stringFlag(parsed, 'provider');
+    if (provider && provider !== 'local') {
+        throw new Error(`aiwg issue is for local issue storage only; configured external trackers use their tracker tools (${provider})`);
+    }
+    const issues = new LocalIssueProviderCore(localIssueRoot(cwd));
+    switch (subcommand) {
+        case 'init':
+            await handleInit(issues, parsed);
+            return;
+        case 'new':
+        case 'create':
+            await handleNew(issues, parsed);
+            return;
+        case 'list':
+        case 'ls':
+            await handleList(issues, parsed);
+            return;
+        case 'show':
+            await handleShow(issues, rest, parsed);
+            return;
+        case 'import':
+            await handleImport(issues, parsed);
+            return;
+        case 'export':
+            await handleExport(issues, rest, parsed);
+            return;
+        case 'sync':
+            await handleSync(issues, rest, parsed);
+            return;
+        case 'comment':
+            await handleComment(issues, rest, parsed);
+            return;
+        case 'close':
+            await handleClose(issues, rest, parsed);
+            return;
+        case 'index':
+            await handleIndex(issues, rest, parsed);
+            return;
+        default:
+            printUsage();
+            if (subcommand)
+                throw new Error(`Unknown issue subcommand: ${subcommand}`);
+    }
+}
+async function handleInit(issues, args) {
+    const padding = stringFlag(args, 'padding');
+    const config = await issues.init({
+        prefix: stringFlag(args, 'prefix'),
+        padding: padding ? Number.parseInt(padding, 10) : undefined,
+    });
+    printJsonOrText(args, config, `Initialized local issues with prefix ${config.issue_key.prefix}`);
+}
+async function handleNew(issues, args) {
+    const title = stringFlag(args, 'title') ?? args.positional[1];
+    if (!title)
+        throw new Error('Usage: aiwg issue new --title <title> [--body <text>|--body-file <path>]');
+    const body = await readBody(args);
+    const issue = await issues.createIssue({
+        title,
+        body,
+        type: stringFlag(args, 'type'),
+        priority: stringFlag(args, 'priority'),
+        labels: csvFlag(args, 'label'),
+        assignees: csvFlag(args, 'assignee'),
+        author: stringFlag(args, 'author'),
+    });
+    printJsonOrText(args, issue, `Created ${issue.fields.id}: ${issue.fields.title}`);
+}
+async function handleList(issues, args) {
+    const limit = stringFlag(args, 'limit');
+    const result = await issues.listIssues({
+        limit: limit ? Number.parseInt(limit, 10) : undefined,
+        cursor: stringFlag(args, 'cursor'),
+        filter: {
+            status: stringFlag(args, 'status'),
+            labels: csvFlag(args, 'label'),
+            type: stringFlag(args, 'type'),
+            priority: stringFlag(args, 'priority'),
+            assignee: stringFlag(args, 'assignee'),
+            search: stringFlag(args, 'search'),
+        },
+    });
+    if (args.flags.has('json')) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    for (const issue of result.issues) {
+        console.log(`${issue.id}\t${issue.status}\t${issue.priority}\t${issue.title}`);
+    }
+    if (result.nextCursor)
+        console.log(`next cursor: ${result.nextCursor}`);
+}
+async function handleShow(issues, rest, args) {
+    const id = rest[0];
+    if (!id)
+        throw new Error('Usage: aiwg issue show <id> [--comments last:10|all]');
+    const issue = await issues.getIssue(id, { comments: (stringFlag(args, 'comments') ?? 'all') });
+    if (args.flags.has('json')) {
+        console.log(JSON.stringify(issue, null, 2));
+        return;
+    }
+    console.log(`# ${issue.fields.id}: ${issue.fields.title}`);
+    console.log(`status: ${issue.fields.status}`);
+    console.log(`priority: ${issue.fields.priority}`);
+    console.log(`labels: ${issue.fields.labels.join(', ') || '(none)'}`);
+    console.log('');
+    console.log(issue.body);
+    if (issue.events.length > 0) {
+        console.log('\n## Events');
+        for (const event of issue.events) {
+            console.log(`- ${event.created_at} ${event.type} by ${event.author}${event.body ? `: ${event.body}` : ''}`);
+        }
+    }
+}
+async function handleImport(issues, args) {
+    const from = stringFlag(args, "from");
+    if (from !== "gitea" && from !== "github")
+        throw new Error("Usage: aiwg issue import --from gitea|github (--snapshot-file path | --live --repo owner/name --external-id N)");
+    const snapshot = args.flags.has("live")
+        ? await createLiveIssueClient({ provider: from, repo: requiredStringFlag(args, "repo"), apiUrl: stringFlag(args, "api-url") }).importIssue(requiredStringFlag(args, "external-id"))
+        : parseExternalIssueSnapshot(JSON.parse(await readRequiredFile(args, "snapshot-file")));
+    if (from !== snapshot.provider)
+        throw new Error(`snapshot provider ${snapshot.provider} does not match --from ${from}`);
+    const issue = await issues.importIssue({
+        provider: snapshot.provider,
+        external_id: snapshot.external_id,
+        external_url: snapshot.external_url,
+        title: snapshot.title,
+        body: snapshot.body,
+        status: snapshot.status,
+        labels: snapshot.labels,
+        created_at: snapshot.created_at,
+        updated_at: snapshot.updated_at,
+        comments: snapshot.comments,
+    });
+    printJsonOrText(args, issue, `Imported ${snapshot.provider}#${snapshot.external_id} as ${issue.fields.id}`);
+}
+async function handleExport(issues, rest, args) {
+    const id = rest[0];
+    if (!id)
+        throw new Error("Usage: aiwg issue export <id> --to gitea|github [--out path] [--live --repo owner/name]");
+    const provider = stringFlag(args, "to");
+    if (provider !== "gitea" && provider !== "github")
+        throw new Error("Usage: aiwg issue export <id> --to gitea|github [--out path] [--live --repo owner/name]");
+    const issue = await issues.getIssue(id, { body: true, comments: "all" });
+    const snapshot = buildExternalIssueSnapshotFromLocal(issue, provider);
+    if (!args.flags.has("live")) {
+        await writeOptionalOutput(args, snapshot);
+        return;
+    }
+    const client = createLiveIssueClient({ provider, repo: requiredStringFlag(args, "repo"), apiUrl: stringFlag(args, "api-url") });
+    if (snapshot.external_id && !args.flags.has("force")) {
+        const remote = await client.fetchIssue(snapshot.external_id);
+        const report = buildLocalIssueConflictReport(issue, remote);
+        if (report.conflicts.length > 0) {
+            throw new Error(`Refusing live export with ${report.conflicts.length} unresolved conflict(s); run sync conflicts or pass --force after review`);
+        }
+    }
+    const result = await client.exportIssue(snapshot);
+    await issues.updateIssueFields(id, {
+        source: { provider, external_id: result.snapshot.external_id, external_url: result.snapshot.external_url ?? null },
+        links: {
+            ...issue.fields.links,
+            external: result.snapshot.external_url ? [...new Set([...issue.fields.links.external, result.snapshot.external_url])] : issue.fields.links.external,
+        },
+    });
+    if (result.commentMappings.length > 0)
+        await issues.applyCommentIdMappings(id, result.commentMappings);
+    await writeOptionalOutput(args, result);
+}
+async function handleSync(issues, rest, args) {
+    const action = rest[0];
+    if (action === 'conflicts' || action === 'conflict-report') {
+        const id = rest[1];
+        if (!id)
+            throw new Error('Usage: aiwg issue sync conflicts <id> --snapshot-file path');
+        const issue = await issues.getIssue(id, { body: true, comments: 'all' });
+        const snapshot = parseExternalIssueSnapshot(JSON.parse(await readRequiredFile(args, 'snapshot-file')));
+        const report = buildLocalIssueConflictReport(issue, snapshot);
+        await writeOptionalOutput(args, report);
+        return;
+    }
+    if (action === 'map-comments') {
+        const id = rest[1];
+        if (!id)
+            throw new Error('Usage: aiwg issue sync map-comments <id> --map-file path');
+        const mappings = parseCommentIdMappings(JSON.parse(await readRequiredFile(args, 'map-file')));
+        const events = await issues.applyCommentIdMappings(id, mappings);
+        printJsonOrText(args, events, `Mapped ${mappings.length} external comment id(s) for ${id}`);
+        return;
+    }
+    throw new Error('Usage: aiwg issue sync conflicts <id> --snapshot-file path | map-comments <id> --map-file path');
+}
+async function handleComment(issues, rest, args) {
+    const id = rest[0];
+    if (!id)
+        throw new Error('Usage: aiwg issue comment <id> --body <text>|--body-file <path>');
+    const body = await readBody(args);
+    const event = await issues.commentIssue(id, body, { author: stringFlag(args, 'author') });
+    printJsonOrText(args, event, `Commented on ${id}`);
+}
+async function handleClose(issues, rest, args) {
+    const id = rest[0];
+    if (!id)
+        throw new Error('Usage: aiwg issue close <id> [--reason <text>|--body-file <path>]');
+    const reason = stringFlag(args, 'reason') ?? stringFlag(args, 'body') ?? await optionalBodyFile(args);
+    const issue = await issues.closeIssue(id, { author: stringFlag(args, 'author'), reason });
+    printJsonOrText(args, issue, `Closed ${issue.fields.id}`);
+}
+async function handleIndex(issues, rest, args) {
+    if (rest[0] !== 'rebuild')
+        throw new Error('Usage: aiwg issue index rebuild');
+    const index = await issues.rebuildIssueIndex();
+    printJsonOrText(args, index, `Rebuilt local issue index (${index.issues.length} issues)`);
+}
+function requiredStringFlag(args, flag) {
+    const value = stringFlag(args, flag);
+    if (!value)
+        throw new Error(`Missing required --${flag}`);
+    return value;
+}
+async function readRequiredFile(args, flag) {
+    const file = stringFlag(args, flag);
+    if (!file)
+        throw new Error(`Missing required --${flag} path`);
+    return readFile(file, 'utf-8');
+}
+async function writeOptionalOutput(args, value) {
+    const out = stringFlag(args, 'out');
+    const rendered = JSON.stringify(value, null, 2) + '\n';
+    if (out) {
+        await writeFile(out, rendered, 'utf-8');
+        if (!args.flags.has('json'))
+            console.log(`Wrote ${out}`);
+        return;
+    }
+    console.log(rendered.trimEnd());
+}
+async function readBody(args) {
+    const body = stringFlag(args, 'body');
+    if (body !== undefined)
+        return body;
+    const bodyFile = stringFlag(args, 'body-file');
+    if (bodyFile)
+        return readFile(bodyFile, 'utf-8');
+    return '';
+}
+async function optionalBodyFile(args) {
+    const bodyFile = stringFlag(args, 'body-file');
+    return bodyFile ? readFile(bodyFile, 'utf-8') : undefined;
+}
+function printJsonOrText(args, value, text) {
+    if (args.flags.has('json')) {
+        console.log(JSON.stringify(value, null, 2));
+    }
+    else {
+        console.log(text);
+    }
+}
+function parseArgs(args) {
+    const positional = [];
+    const flags = new Map();
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg.startsWith('--')) {
+            positional.push(arg);
+            continue;
+        }
+        const [rawKey, inline] = arg.slice(2).split(/=(.*)/s).filter((part) => part !== undefined);
+        if (inline !== undefined && inline !== '') {
+            flags.set(rawKey, inline);
+            continue;
+        }
+        const next = args[i + 1];
+        if (next && !next.startsWith('--')) {
+            flags.set(rawKey, next);
+            i++;
+        }
+        else {
+            flags.set(rawKey, true);
+        }
+    }
+    return { positional, flags };
+}
+function stringFlag(args, name) {
+    const value = args.flags.get(name);
+    if (value === undefined || value === true)
+        return undefined;
+    return String(value);
+}
+function csvFlag(args, name) {
+    const value = stringFlag(args, name);
+    return value ? value.split(',').map((item) => item.trim()).filter(Boolean) : [];
+}
+function printUsage() {
+    console.log(`Usage:
+  aiwg issue init [--prefix KEY] [--padding N]
+  aiwg issue new --title "..." [--body "..."] [--body-file path]
+  aiwg issue list [--status open] [--label bug] [--search text] [--limit 20] [--json]
+  aiwg issue show <KEY> [--comments last:10|all]
+  aiwg issue import --from gitea|github --snapshot-file path [--json]
+  aiwg issue export <KEY> --to gitea|github [--out path]
+  aiwg issue sync conflicts <KEY> --snapshot-file path [--out path]
+  aiwg issue sync map-comments <KEY> --map-file path [--json]
+  aiwg issue comment <KEY> --body "..." [--author name]
+  aiwg issue close <KEY> [--reason "..."]
+  aiwg issue index rebuild`);
+}
+//# sourceMappingURL=cli.js.map

package/dist/src/issues/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './local.js';
+export * from './sync.js';
+export * from './live.js';
+//# sourceMappingURL=index.js.map

package/dist/src/issues/live.js

@@ -0,0 +1,154 @@
+export class LiveIssueClient {
+    options;
+    baseUrl;
+    owner;
+    name;
+    fetchFn;
+    constructor(options) {
+        this.options = options;
+        const [owner, name] = options.repo.split('/');
+        if (!owner || !name || options.repo.split('/').length !== 2) {
+            throw new Error('--repo must be in owner/name form');
+        }
+        this.owner = owner;
+        this.name = name;
+        this.baseUrl = normalizeApiUrl(options.apiUrl ?? defaultApiUrl(options.provider));
+        this.fetchFn = options.fetchFn ?? fetch;
+    }
+    async fetchIssue(externalId) {
+        const issue = await this.request('GET', this.issuePath(externalId));
+        const comments = await this.fetchComments(externalId);
+        return normalizeIssue(this.options.provider, issue, comments);
+    }
+    async importIssue(externalId) {
+        return this.fetchIssue(externalId);
+    }
+    async exportIssue(snapshot) {
+        const hasExternalId = snapshot.external_id.length > 0;
+        const issue = hasExternalId
+            ? await this.request('PATCH', this.issuePath(snapshot.external_id), issueMutationBody(this.options.provider, snapshot))
+            : await this.request('POST', this.issuesPath(), issueMutationBody(this.options.provider, snapshot));
+        const externalId = issueNumber(issue);
+        const commentMappings = [];
+        for (const comment of snapshot.comments) {
+            if (comment.external_id)
+                continue;
+            const posted = await this.request('POST', this.commentsPath(externalId), { body: comment.body });
+            const externalCommentId = requireId(posted.id, 'comment id');
+            commentMappings.push({ local_event_id: comment.local_event_id, external_comment_id: externalCommentId });
+        }
+        return {
+            snapshot: await this.fetchIssue(externalId),
+            commentMappings,
+        };
+    }
+    async fetchComments(externalId) {
+        const comments = await this.request('GET', this.commentsPath(externalId));
+        return comments.map((comment) => normalizeComment(comment));
+    }
+    issuesPath() {
+        return `/repos/${encodeURIComponent(this.owner)}/${encodeURIComponent(this.name)}/issues`;
+    }
+    issuePath(externalId) {
+        return `${this.issuesPath()}/${encodeURIComponent(externalId)}`;
+    }
+    commentsPath(externalId) {
+        return `${this.issuePath(externalId)}/comments`;
+    }
+    async request(method, path, body) {
+        const headers = {
+            Accept: 'application/json',
+        };
+        if (body !== undefined)
+            headers['Content-Type'] = 'application/json';
+        if (this.options.token)
+            headers.Authorization = `Bearer ${this.options.token}`;
+        const response = await this.fetchFn(`${this.baseUrl}${path}`, {
+            method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`${this.options.provider} issue API ${method} ${path} failed: ${response.status}${text ? ` ${redactSecrets(text)}` : ''}`);
+        }
+        return response.json();
+    }
+}
+export function createLiveIssueClient(options) {
+    return new LiveIssueClient({
+        ...options,
+        token: resolveToken(options.provider, options.tokenEnv ?? process.env),
+    });
+}
+export function resolveToken(provider, env) {
+    if (provider === 'gitea')
+        return env.AIWG_GITEA_TOKEN ?? env.GITEA_TOKEN;
+    return env.AIWG_GITHUB_TOKEN ?? env.GITHUB_TOKEN;
+}
+function defaultApiUrl(provider) {
+    if (provider === 'github')
+        return 'https://api.github.com';
+    return process.env.AIWG_GITEA_API_URL ?? process.env.GITEA_API_URL ?? 'https://git.integrolabs.net/api/v1';
+}
+function normalizeApiUrl(value) {
+    return value.replace(/\/+$/, '');
+}
+function issueMutationBody(provider, snapshot) {
+    const body = {
+        title: snapshot.title,
+        body: snapshot.body,
+        labels: snapshot.labels,
+    };
+    if (snapshot.status === 'closed')
+        body.state = 'closed';
+    if (provider === 'gitea' && snapshot.status !== 'closed')
+        body.state = 'open';
+    return body;
+}
+function normalizeIssue(provider, issue, comments) {
+    const updatedAt = requireString(issue.updated_at, 'updated_at');
+    return {
+        provider,
+        external_id: issueNumber(issue),
+        external_url: issue.html_url ?? null,
+        title: requireString(issue.title, 'title'),
+        body: issue.body ?? '',
+        status: issue.state === 'closed' ? 'closed' : 'open',
+        labels: normalizeLabels(issue.labels ?? []),
+        created_at: issue.created_at,
+        updated_at: updatedAt,
+        comments,
+    };
+}
+function normalizeComment(comment) {
+    return {
+        external_id: requireId(comment.id, 'comment id'),
+        author: comment.user?.login ?? comment.user?.username ?? comment.poster?.login ?? comment.poster?.username ?? 'unknown',
+        body: comment.body ?? '',
+        created_at: requireString(comment.created_at, 'comment created_at'),
+        updated_at: comment.updated_at,
+    };
+}
+function normalizeLabels(labels) {
+    return labels.map((label) => typeof label === 'string' ? label : label.name).filter((label) => Boolean(label));
+}
+function issueNumber(issue) {
+    return requireId(issue.number ?? issue.index ?? issue.id, 'issue number');
+}
+function requireId(value, field) {
+    if (typeof value === 'number')
+        return String(value);
+    if (typeof value === 'string' && value.length > 0)
+        return value;
+    throw new Error(`live issue response missing ${field}`);
+}
+function requireString(value, field) {
+    if (typeof value === 'string')
+        return value;
+    throw new Error(`live issue response missing ${field}`);
+}
+function redactSecrets(value) {
+    return value.replace(/(token|authorization|password|secret)["':=\s]+[^\s"',}]+/gi, '$1=[REDACTED]');
+}
+//# sourceMappingURL=live.js.map