@m5kdev/backend 0.1.0

package/src/modules/recurrence/recurrence.db.ts

@@ -0,0 +1,79 @@
+import { integer, sqliteTable as table, text } from "drizzle-orm/sqlite-core";
+import { v4 as uuidv4 } from "uuid";
+import { organizations, teams, users } from "#modules/auth/auth.db";
+
+export const recurrence = table("recurrence", {
+  id: text("id").primaryKey().$default(uuidv4),
+  userId: text("user_id").references(() => users.id, { onDelete: "cascade" }),
+  organizationId: text("organization_id").references(() => organizations.id, {
+    onDelete: "cascade",
+  }),
+  teamId: text("team_id").references(() => teams.id, { onDelete: "cascade" }),
+  name: text("name"),
+  kind: text("kind"),
+  enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .$default(() => new Date()),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .$default(() => new Date()),
+  metadata: text("metadata", { mode: "json" }).$type<Record<string, any>>(),
+});
+
+export const recurrenceRules = table("recurrence_rules", {
+  id: text("id").primaryKey().$default(uuidv4),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .notNull()
+    .$default(() => new Date()),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .$default(() => new Date()),
+  recurrenceId: text("recurrence_id").references(() => recurrence.id, {
+    onDelete: "cascade",
+  }),
+
+  // Required: frequency
+  freq: integer("freq").notNull(),
+
+  // Start date; base for recurrence and source for missing instance params
+  dtstart: integer("dtstart", { mode: "timestamp" }),
+
+  // Interval between each freq iteration (default 1)
+  interval: integer("interval").notNull().default(1),
+
+  // Week start: MO, TU, WE, ... or integer 0–6
+  wkst: integer("wkst"),
+
+  // How many occurrences to generate
+  count: integer("count"),
+
+  // Last occurrence date (inclusive)
+  until: integer("until", { mode: "timestamp" }),
+
+  // IANA timezone string (Intl API)
+  tzid: text("tzid"),
+
+  // BYSETPOS: occurrence number(s) in the frequency period (e.g. -1 = last)
+  bysetpos: text("bysetpos", { mode: "json" }).$type<number | number[]>(),
+
+  // BYMONTH: month(s) 1–12
+  bymonth: text("bymonth", { mode: "json" }).$type<number | number[]>(),
+
+  // BYMONTHDAY: day(s) of month
+  bymonthday: text("bymonthday", { mode: "json" }).$type<number | number[]>(),
+
+  // BYYEARDAY: day(s) of year
+  byyearday: text("byyearday", { mode: "json" }).$type<number | number[]>(),
+
+  // BYWEEKNO: week number(s) (ISO8601)
+  byweekno: text("byweekno", { mode: "json" }).$type<number | number[]>(),
+
+  // BYWEEKDAY: weekday(s) 0–6, or nth e.g. { weekday: 4, n: 1 } for first Friday
+  byweekday: text("byweekday", { mode: "json" }).$type<number | number[]>(),
+
+  // BYHOUR, BYMINUTE, BYSECOND
+  byhour: text("byhour", { mode: "json" }).$type<number | number[]>(),
+  byminute: text("byminute", { mode: "json" }).$type<number | number[]>(),
+  bysecond: text("bysecond", { mode: "json" }).$type<number | number[]>(),
+});

package/src/modules/recurrence/recurrence.repository.ts

@@ -0,0 +1,70 @@
+import type { InferInsertModel, InferSelectModel } from "drizzle-orm";
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import { ok } from "neverthrow";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseTableRepository } from "#modules/base/base.repository";
+import * as recurrence from "#modules/recurrence/recurrence.db";
+
+const schema = { ...recurrence };
+type Schema = typeof schema;
+type Orm = LibSQLDatabase<Schema>;
+type RecurrenceInsert = InferInsertModel<Schema["recurrence"]>;
+type RecurrenceRulesInsert = InferInsertModel<Schema["recurrenceRules"]>;
+
+/** Rule input for create: rule fields without id, recurrenceId, createdAt, updatedAt */
+export type CreateRecurrenceRuleInput = Omit<
+  RecurrenceRulesInsert,
+  "id" | "recurrenceId" | "createdAt" | "updatedAt"
+>;
+
+export interface CreateWithRulesResult {
+  recurrence: InferSelectModel<Schema["recurrence"]>;
+  rules: InferSelectModel<Schema["recurrenceRules"]>[];
+}
+
+export class RecurrenceRepository extends BaseTableRepository<
+  Orm,
+  Schema,
+  Record<string, never>,
+  Schema["recurrence"]
+> {
+  async createWithRules(
+    recurrenceData: RecurrenceInsert,
+    rulesData: CreateRecurrenceRuleInput[],
+    tx?: Orm
+  ): ServerResultAsync<CreateWithRulesResult> {
+    return this.throwableAsync(async () => {
+      const db = tx ?? this.orm;
+      const result = await db.transaction(async (trx) => {
+        const [createdRecurrence] = await trx
+          .insert(this.table)
+          .values(recurrenceData)
+          .returning();
+        if (!createdRecurrence) throw new Error("Failed to create recurrence");
+
+        const rulesWithRecurrenceId: RecurrenceRulesInsert[] = rulesData.map((rule) => ({
+          ...rule,
+          recurrenceId: createdRecurrence.id,
+        }));
+
+        const insertedRules =
+          rulesWithRecurrenceId.length > 0
+            ? await trx
+                .insert(this.schema.recurrenceRules)
+                .values(rulesWithRecurrenceId)
+                .returning()
+            : [];
+
+        return ok({ recurrence: createdRecurrence, rules: insertedRules });
+      });
+      return result;
+    });
+  }
+}
+
+export class RecurrenceRulesRepository extends BaseTableRepository<
+  Orm,
+  Schema,
+  Record<string, never>,
+  Schema["recurrenceRules"]
+> {}

package/src/modules/recurrence/recurrence.service.ts

@@ -0,0 +1,105 @@
+import type {
+  CreateRecurrenceSchema,
+  DeleteRecurrenceRulesSchema,
+  DeleteRecurrenceSchema,
+  UpdateRecurrenceRulesSchema,
+  UpdateRecurrenceSchema,
+} from "@m5kdev/commons/modules/recurrence/recurrence.schema";
+import type { QueryInput } from "@m5kdev/commons/modules/schemas/query.schema";
+import { err, ok } from "neverthrow";
+import type { Context, User } from "#modules/auth/auth.lib";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseService } from "#modules/base/base.service";
+import type {
+  CreateRecurrenceRuleInput,
+  CreateWithRulesResult,
+  RecurrenceRepository,
+  RecurrenceRulesRepository,
+} from "#modules/recurrence/recurrence.repository";
+
+const RECURRENCE_RULE_INSERT_KEYS = [
+  "freq",
+  "dtstart",
+  "interval",
+  "wkst",
+  "count",
+  "until",
+  "tzid",
+  "bysetpos",
+  "bymonth",
+  "bymonthday",
+  "byyearday",
+  "byweekno",
+  "byweekday",
+  "byhour",
+  "byminute",
+  "bysecond",
+] as const;
+
+function mapRuleToInsert(
+  rule: CreateRecurrenceSchema["recurrenceRules"][number]
+): CreateRecurrenceRuleInput {
+  const out: Record<string, unknown> = {};
+  for (const key of RECURRENCE_RULE_INSERT_KEYS) {
+    if (key in rule && rule[key as keyof typeof rule] !== undefined) {
+      out[key] = rule[key as keyof typeof rule];
+    }
+  }
+  return out as CreateRecurrenceRuleInput;
+}
+
+export class RecurrenceService extends BaseService<
+  { recurrence: RecurrenceRepository; recurrenceRules: RecurrenceRulesRepository },
+  Record<string, never>
+> {
+  async create(
+    data: CreateRecurrenceSchema,
+    ctx: Context
+  ): ServerResultAsync<CreateWithRulesResult> {
+    const recurrenceData = {
+      name: data.name,
+      kind: data.kind,
+      enabled: data.enabled,
+      metadata: data.metadata ?? null,
+      userId: ctx.user?.id ?? null,
+      organizationId: ctx.session.activeOrganizationId ?? null,
+      teamId: ctx.session.activeTeamId ?? null,
+    };
+    const rulesData = data.recurrenceRules.map(mapRuleToInsert);
+    return this.repository.recurrence.createWithRules(recurrenceData, rulesData);
+  }
+
+  async list(
+    query?: QueryInput,
+    ctx?: { user?: User }
+  ): ServerResultAsync<{ rows: CreateWithRulesResult["recurrence"][]; total: number }> {
+    const queryWithUser = ctx?.user ? this.addUserFilter(ctx.user.id, query, "userId") : query;
+    return this.repository.recurrence.queryList(queryWithUser);
+  }
+
+  async findById(id: string): ServerResultAsync<CreateWithRulesResult["recurrence"] | null> {
+    const result = await this.repository.recurrence.findById(id);
+    if (result.isErr()) return err(result.error);
+    return ok(result.value ?? null);
+  }
+
+  async update(
+    data: UpdateRecurrenceSchema & { id: string }
+  ): ServerResultAsync<CreateWithRulesResult["recurrence"]> {
+    return this.repository.recurrence.update(data);
+  }
+
+  async updateRule(
+    data: UpdateRecurrenceRulesSchema
+  ): ServerResultAsync<CreateWithRulesResult["rules"][number]> {
+    return this.repository.recurrenceRules.update(data);
+  }
+
+  async delete(data: DeleteRecurrenceSchema): ServerResultAsync<{ id: string }> {
+    return this.repository.recurrence.deleteById(data.id);
+  }
+
+  async deleteRule(data: DeleteRecurrenceRulesSchema): ServerResultAsync<{ id: string }> {
+    return this.repository.recurrenceRules.deleteById(data.id);
+  }
+}

package/src/modules/recurrence/recurrence.trpc.ts

@@ -0,0 +1,82 @@
+import {
+  createRecurrenceSchema,
+  deleteRecurrenceRulesSchema,
+  deleteRecurrenceSchema,
+  recurrenceRulesSchema,
+  recurrenceSchema,
+  updateRecurrenceRulesSchema,
+  updateRecurrenceSchema,
+} from "@m5kdev/commons/modules/recurrence/recurrence.schema";
+import { querySchema } from "@m5kdev/commons/modules/schemas/query.schema";
+import { z } from "zod";
+import type { RecurrenceService } from "#modules/recurrence/recurrence.service";
+import { handleTRPCResult, procedure, router } from "#trpc";
+
+const createRecurrenceOutputSchema = z.object({
+  recurrence: recurrenceSchema,
+  rules: z.array(recurrenceRulesSchema),
+});
+
+const listRecurrenceOutputSchema = z.object({
+  rows: z.array(recurrenceSchema),
+  total: z.number(),
+});
+
+const updateRecurrenceInputSchema = updateRecurrenceSchema.extend({
+  id: z.string(),
+});
+
+const deleteRecurrenceOutputSchema = z.object({ id: z.string() });
+
+export function createRecurrenceTRPC(recurrenceService: RecurrenceService) {
+  return router({
+    list: procedure
+      .input(querySchema.optional())
+      .output(listRecurrenceOutputSchema)
+      .query(async ({ ctx, input }) => {
+        return handleTRPCResult(await recurrenceService.list(input, ctx));
+      }),
+
+    create: procedure
+      .input(createRecurrenceSchema)
+      .output(createRecurrenceOutputSchema)
+      .mutation(async ({ ctx, input }) => {
+        return handleTRPCResult(await recurrenceService.create(input, ctx));
+      }),
+
+    findById: procedure
+      .input(z.object({ id: z.string() }))
+      .output(recurrenceSchema.nullable())
+      .query(async ({ input }) => {
+        return handleTRPCResult(await recurrenceService.findById(input.id));
+      }),
+
+    update: procedure
+      .input(updateRecurrenceInputSchema)
+      .output(recurrenceSchema)
+      .mutation(async ({ input }) => {
+        return handleTRPCResult(await recurrenceService.update(input));
+      }),
+
+    updateRule: procedure
+      .input(updateRecurrenceRulesSchema)
+      .output(recurrenceRulesSchema)
+      .mutation(async ({ input }) => {
+        return handleTRPCResult(await recurrenceService.updateRule(input));
+      }),
+
+    delete: procedure
+      .input(deleteRecurrenceSchema)
+      .output(deleteRecurrenceOutputSchema)
+      .mutation(async ({ input }) => {
+        return handleTRPCResult(await recurrenceService.delete(input));
+      }),
+
+    deleteRule: procedure
+      .input(deleteRecurrenceRulesSchema)
+      .output(deleteRecurrenceOutputSchema)
+      .mutation(async ({ input }) => {
+        return handleTRPCResult(await recurrenceService.deleteRule(input));
+      }),
+  });
+}

package/src/modules/social/social.dto.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+
+export const socialMediaInputSchema = z.object({
+  s3Path: z.string().min(1, "Media S3 path is required"),
+  mediaType: z.enum(["image", "video", "document"]).optional(),
+  title: z.string().max(300).optional(),
+  description: z.string().max(2000).optional(),
+});
+
+export const socialPostInputSchema = z.object({
+  text: z.string().min(1, "Post text is required"),
+  media: z.array(socialMediaInputSchema).max(4).optional(),
+  visibility: z.enum(["PUBLIC", "CONNECTIONS"]).default("PUBLIC"),
+});
+
+export const socialPostOutputSchema = z.object({
+  shareUrn: z.string().optional(),
+});
+
+export type SocialPostInput = z.infer<typeof socialPostInputSchema>;
+export type SocialMediaInput = z.infer<typeof socialMediaInputSchema>;
+export type SocialPostOutput = z.infer<typeof socialPostOutputSchema>;

package/src/modules/social/social.linkedin.test.ts

@@ -0,0 +1,277 @@
+import { escapeLinkedInText } from "./social.linkedin";
+
+describe("escapeLinkedInText", () => {
+  describe("special character escaping", () => {
+    it("escapes backslash", () => {
+      expect(escapeLinkedInText("path\\to\\file")).toBe("path\\\\to\\\\file");
+    });
+
+    it("escapes pipe", () => {
+      expect(escapeLinkedInText("a|b")).toBe("a\\|b");
+    });
+
+    it("escapes curly braces", () => {
+      expect(escapeLinkedInText("{value}")).toBe("\\{value\\}");
+    });
+
+    it("escapes at symbol", () => {
+      expect(escapeLinkedInText("email@example.com")).toBe("email\\@example.com");
+    });
+
+    it("escapes square brackets", () => {
+      expect(escapeLinkedInText("[item]")).toBe("\\[item\\]");
+    });
+
+    it("escapes parentheses", () => {
+      expect(escapeLinkedInText("(note)")).toBe("\\(note\\)");
+    });
+
+    it("escapes angle brackets", () => {
+      expect(escapeLinkedInText("<html>")).toBe("\\<html\\>");
+    });
+
+    it("escapes hash when not a hashtag", () => {
+      expect(escapeLinkedInText("item #1")).toBe("item \\#1");
+    });
+
+    it("escapes asterisk", () => {
+      expect(escapeLinkedInText("*bold*")).toBe("\\*bold\\*");
+    });
+
+    it("escapes underscore", () => {
+      expect(escapeLinkedInText("_italic_")).toBe("\\_italic\\_");
+    });
+
+    it("escapes tilde", () => {
+      expect(escapeLinkedInText("~strikethrough~")).toBe("\\~strikethrough\\~");
+    });
+
+    it("escapes multiple special characters together", () => {
+      expect(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 = 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 = 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 = 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 = 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 = 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 = escapeLinkedInText(input);
+      expect(result).toBe("Check {hashtag|\\#|MyTag}");
+    });
+
+    it("preserves hashtag template with unescaped hash", () => {
+      const input = "Check {hashtag|#|MyTag}";
+      const result = escapeLinkedInText(input);
+      expect(result).toBe("Check {hashtag|#|MyTag}");
+    });
+
+    it("preserves hashtag template with fullwidth hash", () => {
+      const input = "Check {hashtag|＃|MyTag}";
+      const result = escapeLinkedInText(input);
+      expect(result).toBe("Check {hashtag|＃|MyTag}");
+    });
+
+    it("preserves multiple hashtag templates", () => {
+      const input = "{hashtag|\\#|Tag1} and {hashtag|\\#|Tag2}";
+      const result = 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 = escapeLinkedInText(input);
+      expect(result).toBe("Check out {hashtag|\\#|MyHashtag}");
+    });
+
+    it("converts multiple simple hashtags", () => {
+      const input = "#Hello #World";
+      const result = escapeLinkedInText(input);
+      expect(result).toBe("{hashtag|\\#|Hello} {hashtag|\\#|World}");
+    });
+
+    it("converts hashtag with accented characters", () => {
+      const input = "#Café #Naïve";
+      const result = escapeLinkedInText(input);
+      expect(result).toBe("{hashtag|\\#|Café} {hashtag|\\#|Naïve}");
+    });
+
+    it("handles hashtag at end of text", () => {
+      const input = "Great post #Amazing";
+      const result = 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 = 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 = 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 = 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 = escapeLinkedInText(input);
+      expect(result).toBe("Line 1 \\(note\\)\nLine 2 \\[item\\]");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("handles empty string", () => {
+      expect(escapeLinkedInText("")).toBe("");
+    });
+
+    it("handles plain text without special characters", () => {
+      const input = "Hello world this is plain text";
+      expect(escapeLinkedInText(input)).toBe("Hello world this is plain text");
+    });
+
+    it("handles text with only special characters", () => {
+      expect(escapeLinkedInText("@#$")).toBe("\\@\\#$");
+    });
+
+    it("does not double-escape already escaped backslashes in mentions", () => {
+      const input = "@[Test\\Name](urn:li:person:123)";
+      const result = 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(escapeLinkedInText(input)).toBe(expected);
+    });
+  });
+});