@m5kdev/backend 0.1.1 → 0.1.3

package/dist/src/modules/social/social.linkedin.js

@@ -0,0 +1,427 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLinkedInSocialProvider = createLinkedInSocialProvider;
+exports.escapeLinkedInText = escapeLinkedInText;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const LINKEDIN_API_BASE = "https://api.linkedin.com/rest";
+const LINKEDIN_VERSION = "202601";
+const IMAGES_URL = `${LINKEDIN_API_BASE}/images?action=initializeUpload`;
+const VIDEOS_URL = `${LINKEDIN_API_BASE}/videos?action=initializeUpload`;
+const VIDEOS_FINALIZE_URL = `${LINKEDIN_API_BASE}/videos?action=finalizeUpload`;
+const DOCUMENTS_URL = `${LINKEDIN_API_BASE}/documents?action=initializeUpload`;
+const POSTS_URL = `${LINKEDIN_API_BASE}/posts`;
+function getApiHeaders(accessToken) {
+    return {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        "Linkedin-Version": LINKEDIN_VERSION,
+        "X-Restli-Protocol-Version": "2.0.0",
+    };
+}
+function createLinkedInSocialProvider() {
+    return {
+        id: "linkedin",
+        async post({ deps, context, payload }) {
+            const personUrn = resolveAuthorUrn(context.connection);
+            const mediaDescriptors = payload.media ?? [];
+            let uploadedAssets = [];
+            if (mediaDescriptors.length > 0) {
+                uploadedAssets = await uploadMediaAssets({
+                    accessToken: context.accessToken,
+                    fileService: deps.fileService,
+                    mediaDescriptors,
+                    personUrn,
+                });
+            }
+            const response = await publishPost({
+                accessToken: context.accessToken,
+                personUrn,
+                payload,
+                uploadedAssets,
+            });
+            return {
+                shareUrn: response.postUrn,
+                rawResponse: response.raw,
+            };
+        },
+    };
+}
+function resolveAuthorUrn(connection) {
+    if (connection.metadataJson) {
+        try {
+            const metadata = connection.metadataJson;
+            if (metadata.linkedInUrn && typeof metadata.linkedInUrn === "string") {
+                return metadata.linkedInUrn;
+            }
+        }
+        catch {
+            throw new Error("Failed to parse LinkedIn connection metadata");
+        }
+    }
+    if (connection.providerAccountId) {
+        return `urn:li:person:${connection.providerAccountId}`;
+    }
+    throw new Error("LinkedIn connection is missing a person URN");
+}
+async function uploadMediaAssets(params) {
+    const results = [];
+    for (const descriptor of params.mediaDescriptors) {
+        const download = await params.fileService.downloadS3ToFile(descriptor.s3Path);
+        if (download.isErr()) {
+            throw download.error;
+        }
+        const localPath = download.value;
+        try {
+            const mediaType = determineMediaType(descriptor.mediaType, localPath);
+            let assetUrn;
+            switch (mediaType) {
+                case "image":
+                    assetUrn = await uploadImage({
+                        accessToken: params.accessToken,
+                        personUrn: params.personUrn,
+                        localPath,
+                    });
+                    break;
+                case "video":
+                    assetUrn = await uploadVideo({
+                        accessToken: params.accessToken,
+                        personUrn: params.personUrn,
+                        localPath,
+                    });
+                    break;
+                case "document":
+                    assetUrn = await uploadDocument({
+                        accessToken: params.accessToken,
+                        personUrn: params.personUrn,
+                        localPath,
+                    });
+                    break;
+            }
+            results.push({
+                assetUrn,
+                mediaType,
+                title: descriptor.title,
+                description: descriptor.description,
+            });
+        }
+        finally {
+            await (0, promises_1.unlink)(localPath).catch(() => undefined);
+        }
+    }
+    return results;
+}
+function determineMediaType(explicitType, localPath) {
+    if (explicitType) {
+        return explicitType;
+    }
+    const extension = localPath.split(".").pop()?.toLowerCase();
+    if (!extension) {
+        throw new Error("Unable to determine media type from file extension");
+    }
+    const imageExtensions = new Set(["jpg", "jpeg", "png", "gif", "webp"]);
+    const videoExtensions = new Set(["mp4", "mov", "m4v", "avi", "mkv", "webm"]);
+    const documentExtensions = new Set(["pdf", "ppt", "pptx", "doc", "docx"]);
+    if (imageExtensions.has(extension)) {
+        return "image";
+    }
+    if (videoExtensions.has(extension)) {
+        return "video";
+    }
+    if (documentExtensions.has(extension)) {
+        return "document";
+    }
+    throw new Error(`Unsupported media extension: ${extension}`);
+}
+async function uploadImage(params) {
+    const initResponse = await fetch(IMAGES_URL, {
+        method: "POST",
+        headers: getApiHeaders(params.accessToken),
+        body: JSON.stringify({
+            initializeUploadRequest: {
+                owner: params.personUrn,
+            },
+        }),
+    });
+    if (!initResponse.ok) {
+        const errorText = await initResponse.text().catch(() => "");
+        throw new Error(`LinkedIn image upload initialization failed: ${initResponse.status} ${errorText}`);
+    }
+    const initJson = (await initResponse.json());
+    const { uploadUrl, image } = initJson.value;
+    if (!uploadUrl || !image) {
+        throw new Error("LinkedIn image initialization response missing required fields");
+    }
+    await uploadBinaryToLinkedIn({
+        uploadUrl,
+        localPath: params.localPath,
+        mimeType: inferImageMime(params.localPath),
+    });
+    return image;
+}
+async function uploadVideo(params) {
+    const fileSizeBytes = await getFileSize(params.localPath);
+    const initResponse = await fetch(VIDEOS_URL, {
+        method: "POST",
+        headers: getApiHeaders(params.accessToken),
+        body: JSON.stringify({
+            initializeUploadRequest: {
+                owner: params.personUrn,
+                fileSizeBytes,
+                uploadCaptions: false,
+                uploadThumbnail: false,
+            },
+        }),
+    });
+    if (!initResponse.ok) {
+        const errorText = await initResponse.text().catch(() => "");
+        throw new Error(`LinkedIn video upload initialization failed: ${initResponse.status} ${errorText}`);
+    }
+    const initJson = (await initResponse.json());
+    const { uploadInstructions, video, uploadToken } = initJson.value;
+    if (!uploadInstructions || !video || !uploadToken) {
+        throw new Error("LinkedIn video initialization response missing required fields");
+    }
+    const uploadedPartIds = await uploadVideoMultipart({
+        localPath: params.localPath,
+        uploadInstructions,
+    });
+    await finalizeVideoUpload({
+        accessToken: params.accessToken,
+        video,
+        uploadToken,
+        uploadedPartIds,
+    });
+    return video;
+}
+async function uploadVideoMultipart(params) {
+    const uploadedPartIds = [];
+    for (const instruction of params.uploadInstructions) {
+        const chunkStream = (0, node_fs_1.createReadStream)(params.localPath, {
+            start: instruction.firstByte,
+            end: instruction.lastByte,
+        });
+        const uploadResponse = await fetch(instruction.uploadUrl, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/octet-stream",
+            },
+            body: chunkStream,
+            duplex: "half",
+        });
+        if (!uploadResponse.ok) {
+            const errorText = await uploadResponse.text().catch(() => "");
+            throw new Error(`LinkedIn video part upload failed: ${uploadResponse.status} ${errorText}`);
+        }
+        const etag = uploadResponse.headers.get("etag");
+        if (!etag) {
+            throw new Error("LinkedIn video part upload response missing ETag header");
+        }
+        uploadedPartIds.push(etag.replace(/"/g, ""));
+    }
+    return uploadedPartIds;
+}
+async function finalizeVideoUpload(params) {
+    const response = await fetch(VIDEOS_FINALIZE_URL, {
+        method: "POST",
+        headers: getApiHeaders(params.accessToken),
+        body: JSON.stringify({
+            finalizeUploadRequest: {
+                video: params.video,
+                uploadToken: params.uploadToken,
+                uploadedPartIds: params.uploadedPartIds,
+            },
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => "");
+        throw new Error(`LinkedIn video finalize failed: ${response.status} ${errorText}`);
+    }
+}
+async function uploadDocument(params) {
+    const initResponse = await fetch(DOCUMENTS_URL, {
+        method: "POST",
+        headers: getApiHeaders(params.accessToken),
+        body: JSON.stringify({
+            initializeUploadRequest: {
+                owner: params.personUrn,
+            },
+        }),
+    });
+    if (!initResponse.ok) {
+        const errorText = await initResponse.text().catch(() => "");
+        throw new Error(`LinkedIn document upload initialization failed: ${initResponse.status} ${errorText}`);
+    }
+    const initJson = (await initResponse.json());
+    const { uploadUrl, document } = initJson.value;
+    if (!uploadUrl || !document) {
+        throw new Error("LinkedIn document initialization response missing required fields");
+    }
+    await uploadBinaryToLinkedIn({
+        uploadUrl,
+        localPath: params.localPath,
+        mimeType: inferDocumentMime(params.localPath),
+    });
+    return document;
+}
+async function uploadBinaryToLinkedIn(params) {
+    const uploadResponse = await fetch(params.uploadUrl, {
+        method: "PUT",
+        headers: {
+            "Content-Type": params.mimeType,
+        },
+        body: (0, node_fs_1.createReadStream)(params.localPath),
+        duplex: "half",
+    });
+    if (!uploadResponse.ok) {
+        const errorText = await uploadResponse.text().catch(() => "");
+        throw new Error(`LinkedIn media upload failed: ${uploadResponse.status} ${errorText}`);
+    }
+}
+async function getFileSize(filePath) {
+    const stats = await (0, promises_1.stat)(filePath);
+    return stats.size;
+}
+function inferImageMime(localPath) {
+    const extension = localPath.split(".").pop()?.toLowerCase();
+    switch (extension) {
+        case "png":
+            return "image/png";
+        case "webp":
+            return "image/webp";
+        case "gif":
+            return "image/gif";
+        case "jpg":
+        case "jpeg":
+            return "image/jpeg";
+        default:
+            return "application/octet-stream";
+    }
+}
+function inferDocumentMime(localPath) {
+    const extension = localPath.split(".").pop()?.toLowerCase();
+    switch (extension) {
+        case "pdf":
+            return "application/pdf";
+        case "doc":
+            return "application/msword";
+        case "docx":
+            return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+        case "ppt":
+            return "application/vnd.ms-powerpoint";
+        case "pptx":
+            return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+        default:
+            return "application/octet-stream";
+    }
+}
+async function publishPost(params) {
+    const body = buildPostBody(params);
+    const response = await fetch(POSTS_URL, {
+        method: "POST",
+        headers: getApiHeaders(params.accessToken),
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => "");
+        throw new Error(`LinkedIn post failed: ${response.status} ${errorText}`);
+    }
+    const postUrn = response.headers.get("x-restli-id") ?? undefined;
+    const raw = await safeJson(response);
+    return { postUrn, raw };
+}
+/**
+ * Escapes special characters in text for LinkedIn's post commentary field.
+ * LinkedIn requires certain characters to be backslash-escaped.
+ * Preserves mentions (@[Name](urn:li:...)) and hashtag templates ({hashtag|#|tag}).
+ * Converts simple hashtags (#tag) to the template format.
+ * @see https://learn.microsoft.com/en-us/linkedin/marketing/community-management/shares/little-text-format
+ */
+function escapeLinkedInText(text) {
+    // Patterns for LinkedIn elements that should not be escaped
+    // MentionElement: @[FallbackText](urn:li:...)
+    const mentionPattern = /@\[[^\]]*\]\(urn:li:[^)]+\)/g;
+    // HashtagTemplate: {hashtag|#|text} or {hashtag|＃|text} (with optional escaped #)
+    const hashtagTemplatePattern = /\{hashtag\|\\?[#＃]\|[^}]+\}/g;
+    // Simple hashtag: #word (must start with a letter, not digit-only)
+    const simpleHashtagPattern = /#([a-zA-Z\u00C0-\u024F\u1E00-\u1EFF][\w\u00C0-\u024F\u1E00-\u1EFF]*)/g;
+    // Store matches in array, use index-based placeholders with null character delimiters
+    const preserved = [];
+    const createPlaceholder = (content) => {
+        const index = preserved.length;
+        preserved.push(content);
+        return `\x00${index}\x00`;
+    };
+    // Replace mentions with placeholders (preserve as-is)
+    let result = text.replace(mentionPattern, (match) => createPlaceholder(match));
+    // Replace hashtag templates with placeholders (preserve as-is)
+    result = result.replace(hashtagTemplatePattern, (match) => createPlaceholder(match));
+    // Convert simple hashtags to template format with escaped #
+    result = result.replace(simpleHashtagPattern, (_match, tag) => createPlaceholder(`{hashtag|\\#|${tag}}`));
+    // Escape remaining special characters (order matters: backslash first)
+    result = result
+        .replace(/\\/g, "\\\\")
+        .replace(/\|/g, "\\|")
+        .replace(/\{/g, "\\{")
+        .replace(/\}/g, "\\}")
+        .replace(/@/g, "\\@")
+        .replace(/\[/g, "\\[")
+        .replace(/\]/g, "\\]")
+        .replace(/\(/g, "\\(")
+        .replace(/\)/g, "\\)")
+        .replace(/</g, "\\<")
+        .replace(/>/g, "\\>")
+        .replace(/#/g, "\\#")
+        .replace(/\*/g, "\\*")
+        .replace(/_/g, "\\_")
+        .replace(/~/g, "\\~");
+    // Restore placeholders with preserved/transformed content
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: null chars are intentional placeholders
+    result = result.replace(/\x00(\d+)\x00/g, (_match, index) => preserved[Number(index)]);
+    return result;
+}
+function buildPostBody(params) {
+    const { personUrn, payload, uploadedAssets } = params;
+    const basePost = {
+        author: personUrn,
+        commentary: escapeLinkedInText(payload.text),
+        visibility: payload.visibility,
+        distribution: {
+            feedDistribution: "MAIN_FEED",
+            targetEntities: [],
+            thirdPartyDistributionChannels: [],
+        },
+        lifecycleState: "PUBLISHED",
+        isReshareDisabledByAuthor: false,
+    };
+    if (uploadedAssets.length === 0) {
+        return basePost;
+    }
+    if (uploadedAssets.length > 1) {
+        throw new Error("LinkedIn Posts API currently supports only a single media asset per post");
+    }
+    const asset = uploadedAssets[0];
+    const mediaContent = {
+        id: asset.assetUrn,
+    };
+    if (asset.title) {
+        mediaContent.title = asset.title;
+    }
+    if (asset.description && asset.mediaType === "image") {
+        mediaContent.altText = asset.description;
+    }
+    return {
+        ...basePost,
+        content: {
+            media: mediaContent,
+        },
+    };
+}
+async function safeJson(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/src/modules/social/social.linkedin.test.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const social_linkedin_1 = require("./social.linkedin");
+describe("escapeLinkedInText", () => {
+    describe("special character escaping", () => {
+        it("escapes backslash", () => {
+            expect((0, social_linkedin_1.escapeLinkedInText)("path\\to\\file")).toBe("path\\\\to\\\\file");
+        });
+        it("escapes pipe", () => {
+            expect((0, social_linkedin_1.escapeLinkedInText)("a|b")).toBe("a\\|b");
+        });
+        it("escapes curly braces", () => {
+            expect((0, social_linkedin_1.escapeLinkedInText)("{value}")).toBe("\\{value\\}");
+        });
+        it("escapes at symbol", () => {
+            expect((0, social_linkedin_1.escapeLinkedInText)("email@example.com")).toBe("email\\@example.com");
+        });
+        it("escapes square brackets", () => {
+            expect((0, social_linkedin_1.escapeLinkedInText)("[item]")).toBe("\\[item\\]");
+        });
+        it("escapes parentheses", () => {
+            expect((0, social_linkedin_1.escapeLinkedInText)("(note)")).toBe("\\(note\\)");
+        });
+        it("escapes angle brackets", () => {
+            expect((0, social_linkedin_1.escapeLinkedInText)("<html>")).toBe("\\<html\\>");
+        });
+        it("escapes hash when not a hashtag", () => {
+            expect((0, social_linkedin_1.escapeLinkedInText)("item #1")).toBe("item \\#1");
+        });
+        it("escapes asterisk", () => {
+            expect((0, social_linkedin_1.escapeLinkedInText)("*bold*")).toBe("\\*bold\\*");
+        });
+        it("escapes underscore", () => {
+            expect((0, social_linkedin_1.escapeLinkedInText)("_italic_")).toBe("\\_italic\\_");
+        });
+        it("escapes tilde", () => {
+            expect((0, social_linkedin_1.escapeLinkedInText)("~strikethrough~")).toBe("\\~strikethrough\\~");
+        });
+        it("escapes multiple special characters together", () => {
+            expect((0, social_linkedin_1.escapeLinkedInText)("Check out (this) & [that]!")).toBe("Check out \\(this\\) & \\[that\\]!");
+        });
+    });
+    describe("mentions preservation", () => {
+        it("preserves person mention", () => {
+            const input = "Hello @[John Doe](urn:li:person:123456)!";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("Hello @[John Doe](urn:li:person:123456)!");
+        });
+        it("preserves organization mention", () => {
+            const input = "Check out @[DevtestCo](urn:li:organization:2414183)";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("Check out @[DevtestCo](urn:li:organization:2414183)");
+        });
+        it("preserves mention without fallback text", () => {
+            const input = "Mention @[](urn:li:person:123) here";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("Mention @[](urn:li:person:123) here");
+        });
+        it("preserves multiple mentions", () => {
+            const input = "Thanks @[Alice](urn:li:person:111) and @[Bob](urn:li:person:222)!";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("Thanks @[Alice](urn:li:person:111) and @[Bob](urn:li:person:222)!");
+        });
+        it("escapes text around mentions", () => {
+            const input = "(Hello) @[John](urn:li:person:123) [world]";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("\\(Hello\\) @[John](urn:li:person:123) \\[world\\]");
+        });
+    });
+    describe("hashtag template preservation", () => {
+        it("preserves hashtag template with escaped hash", () => {
+            const input = "Check {hashtag|\\#|MyTag}";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("Check {hashtag|\\#|MyTag}");
+        });
+        it("preserves hashtag template with unescaped hash", () => {
+            const input = "Check {hashtag|#|MyTag}";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("Check {hashtag|#|MyTag}");
+        });
+        it("preserves hashtag template with fullwidth hash", () => {
+            const input = "Check {hashtag|＃|MyTag}";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("Check {hashtag|＃|MyTag}");
+        });
+        it("preserves multiple hashtag templates", () => {
+            const input = "{hashtag|\\#|Tag1} and {hashtag|\\#|Tag2}";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("{hashtag|\\#|Tag1} and {hashtag|\\#|Tag2}");
+        });
+    });
+    describe("simple hashtag conversion", () => {
+        it("converts simple hashtag to template format", () => {
+            const input = "Check out #MyHashtag";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("Check out {hashtag|\\#|MyHashtag}");
+        });
+        it("converts multiple simple hashtags", () => {
+            const input = "#Hello #World";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("{hashtag|\\#|Hello} {hashtag|\\#|World}");
+        });
+        it("converts hashtag with accented characters", () => {
+            const input = "#Café #Naïve";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("{hashtag|\\#|Café} {hashtag|\\#|Naïve}");
+        });
+        it("handles hashtag at end of text", () => {
+            const input = "Great post #Amazing";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("Great post {hashtag|\\#|Amazing}");
+        });
+        it("does not convert hash followed by number only", () => {
+            const input = "Item #1 is great";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("Item \\#1 is great");
+        });
+    });
+    describe("mixed content", () => {
+        it("handles mentions, hashtags, and special chars together", () => {
+            const input = "Hello @[John](urn:li:person:123)! Check out #Tech & (amazing) *stuff*";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("Hello @[John](urn:li:person:123)! Check out {hashtag|\\#|Tech} & \\(amazing\\) \\*stuff\\*");
+        });
+        it("handles pre-formatted hashtag template with mentions", () => {
+            const input = "@[Company](urn:li:organization:123) is doing {hashtag|\\#|GreatThings}!";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("@[Company](urn:li:organization:123) is doing {hashtag|\\#|GreatThings}!");
+        });
+        it("preserves newlines and escapes special chars", () => {
+            const input = "Line 1 (note)\nLine 2 [item]";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            expect(result).toBe("Line 1 \\(note\\)\nLine 2 \\[item\\]");
+        });
+    });
+    describe("edge cases", () => {
+        it("handles empty string", () => {
+            expect((0, social_linkedin_1.escapeLinkedInText)("")).toBe("");
+        });
+        it("handles plain text without special characters", () => {
+            const input = "Hello world this is plain text";
+            expect((0, social_linkedin_1.escapeLinkedInText)(input)).toBe("Hello world this is plain text");
+        });
+        it("handles text with only special characters", () => {
+            expect((0, social_linkedin_1.escapeLinkedInText)("@#$")).toBe("\\@\\#$");
+        });
+        it("does not double-escape already escaped backslashes in mentions", () => {
+            const input = "@[Test\\Name](urn:li:person:123)";
+            const result = (0, social_linkedin_1.escapeLinkedInText)(input);
+            // The mention is preserved as-is, including internal backslash
+            expect(result).toBe("@[Test\\Name](urn:li:person:123)");
+        });
+    });
+    describe("real-world posts", () => {
+        it("handles a full LinkedIn post with hashtags and special characters", () => {
+            const input = `I tried that prompt going around lately: "Draw a picture of how I'm treating you."
+
+
+My result was just a happy little bot (picture included).
+
+
+But when I scrolled through LinkedIn, I noticed something different. People were posting unhappy bots: overworked assistants and robots in chains. There was a lot of "you did it wrong" or "fix it" energy.
+
+
+Here is the thing: I don't anthropomorphize AI. I don't chat with it about my day. I use it as a tool for specific tasks. Yet, I still find myself typing "please" and "thank you" in my prompts.
+
+
+I am the same way with games. In RPGs, I almost always pick the "good guy" route. I tried to play the renegade path in Mass Effect once and couldn't even finish it. It just felt wrong.
+
+
+Contrast that with a trend I've been seeing lately. There are papers and plenty of anecdotes suggesting that negative feedback, harsh wording, or even subtle "threats" can actually squeeze better answers out of these models.
+
+
+That creates a weird tension for me:
+
+
+Intellectually, I know adversarial prompting can work.
+Practically, I can't bring myself to be mean to what is essentially linear algebra wrapped in a UI.
+Personally, I don't think training myself to be rude, even to a tool, is a habit I want to cultivate.
+
+
+Maybe the real optimization isn't about being harsh, but being clear. Well-scoped tasks, concrete constraints, and explicit feedback usually do the heavy lifting anyway.
+
+
+I'm curious how others handle this, especially if you spend most of day in AI tools:
+
+
+Do you consciously change your tone to get better results?
+Have you actually seen consistent gains from theating or adversarial prompts?
+Do you think how we talk to AI will eventually bleed into how we talk to humans?
+
+
+#AI #LLM #PromptEngineering`;
+            const expected = `I tried that prompt going around lately: "Draw a picture of how I'm treating you."
+
+
+My result was just a happy little bot \\(picture included\\).
+
+
+But when I scrolled through LinkedIn, I noticed something different. People were posting unhappy bots: overworked assistants and robots in chains. There was a lot of "you did it wrong" or "fix it" energy.
+
+
+Here is the thing: I don't anthropomorphize AI. I don't chat with it about my day. I use it as a tool for specific tasks. Yet, I still find myself typing "please" and "thank you" in my prompts.
+
+
+I am the same way with games. In RPGs, I almost always pick the "good guy" route. I tried to play the renegade path in Mass Effect once and couldn't even finish it. It just felt wrong.
+
+
+Contrast that with a trend I've been seeing lately. There are papers and plenty of anecdotes suggesting that negative feedback, harsh wording, or even subtle "threats" can actually squeeze better answers out of these models.
+
+
+That creates a weird tension for me:
+
+
+Intellectually, I know adversarial prompting can work.
+Practically, I can't bring myself to be mean to what is essentially linear algebra wrapped in a UI.
+Personally, I don't think training myself to be rude, even to a tool, is a habit I want to cultivate.
+
+
+Maybe the real optimization isn't about being harsh, but being clear. Well-scoped tasks, concrete constraints, and explicit feedback usually do the heavy lifting anyway.
+
+
+I'm curious how others handle this, especially if you spend most of day in AI tools:
+
+
+Do you consciously change your tone to get better results?
+Have you actually seen consistent gains from theating or adversarial prompts?
+Do you think how we talk to AI will eventually bleed into how we talk to humans?
+
+
+{hashtag|\\#|AI} {hashtag|\\#|LLM} {hashtag|\\#|PromptEngineering}`;
+            expect((0, social_linkedin_1.escapeLinkedInText)(input)).toBe(expected);
+        });
+    });
+});