diff --git a/src/services/ghost/strategies/CommentHelpers.ts b/src/services/ghost/strategies/CommentHelpers.ts
index 0f961f2476c..9abd6d77aaa 100644
--- a/src/services/ghost/strategies/CommentHelpers.ts
+++ b/src/services/ghost/strategies/CommentHelpers.ts
@@ -6,8 +6,19 @@ import { TextDocument } from "vscode"
 export function isCommentLine(line: string, languageId: string): boolean {
 	const trimmed = line.trim()
 
-	// Common single-line comment patterns
-	const singleLinePatterns = [
+	const patterns = [
+		// Structural patterns
+		/^\/\*$/, // C-style block start
+		/^<!--$/, // HTML comment start
+		/^"""$/, // Python docstring
+		/^'''$/, // Python docstring alternative
+		// Multi-line patterns
+		/^\/\*/, // C-style
+		/^\*/, // Inside C-style block
+		/^<!--/, // HTML, XML
+		/^"""/, // Python docstring
+		/^'''/, // Python docstring alternative
+		// Single-line patterns
 		/^\/\//, // JavaScript, TypeScript, C++, Java, etc.
 		/^#/, // Python, Ruby, Shell, etc.
 		/^--/, // SQL, Haskell, Lua
@@ -16,47 +27,15 @@ export function isCommentLine(line: string, languageId: string): boolean {
 		/^'/, // VB
 	]
 
-	// Multi-line comment patterns
-	const multiLinePatterns = [
-		/^\/\*/, // C-style
-		/^\*/, // Inside C-style block
-		/^<!--/, // HTML, XML
-		/^"""/, // Python docstring
-		/^'''/, // Python docstring alternative
-	]
-
-	// Check single-line patterns
-	if (singleLinePatterns.some((pattern) => pattern.test(trimmed))) {
-		// Make sure it contains meaningful text (not just comment syntax)
-		const withoutCommentSyntax = trimmed.replace(/^(\/\/|#|--|;|%|')\s*/, "")
-		return withoutCommentSyntax.length > 0
-	}
-
-	// Check multi-line patterns
-	if (multiLinePatterns.some((pattern) => pattern.test(trimmed))) {
-		return true
+	for (const pattern of patterns) {
+		const match = trimmed.match(pattern)
+		if (match) {
+			const withoutSyntax = trimmed.slice(match[0].length).trim()
+			return withoutSyntax.length > 0
+		}
 	}
 
-	// Language-specific checks
-	switch (languageId) {
-		case "python":
-			return /^#/.test(trimmed) || /^("""|''')/.test(trimmed)
-		case "javascript":
-		case "typescript":
-		case "javascriptreact":
-		case "typescriptreact":
-			return /^(\/\/|\/\*|\*)/.test(trimmed)
-		case "html":
-		case "xml":
-			return /^<!--/.test(trimmed)
-		case "css":
-		case "scss":
-		case "less":
-			return /^(\/\*|\*)/.test(trimmed)
-		default:
-			// Default to common patterns
-			return /^(\/\/|#|\/\*|\*)/.test(trimmed)
-	}
+	return false
 }
 
 export function extractComment(document: TextDocument, currentLine: number): string {
@@ -115,20 +94,32 @@ export function extractComment(document: TextDocument, currentLine: number): str
 export function cleanComment(comment: string, languageId: string): string {
 	const lines = comment.split("\n")
 	const cleaned = lines.map((line) => {
-		// Remove common comment prefixes
-		return line
+		let cleaned = line.trim()
+
+		// Remove common comment prefixes (order matters)
+		cleaned = cleaned
 			.replace(/^\/\/\s*/, "") // //
 			.replace(/^\/\*\s*/, "") // /*
-			.replace(/^\*\s*/, "") // *
-			.replace(/\*\/\s*$/, "") // */
+			.replace(/^\*\s+/, "") // * with required space after
 			.replace(/^#\s*/, "") // #
 			.replace(/^--\s*/, "") // --
 			.replace(/^;\s*/, "") // ;
 			.replace(/^%\s*/, "") // %
 			.replace(/^'\s*/, "") // '
 			.replace(/^<!--\s*/, "") // <!--
-			.replace(/-->\s*$/, "") // -->
-			.trim()
+
+		// Remove trailing comment syntax and everything after the last occurrence
+		const lastCommentEnd = cleaned.lastIndexOf("*/")
+		if (lastCommentEnd !== -1) {
+			cleaned = cleaned.substring(0, lastCommentEnd).trim()
+		}
+
+		const lastHtmlCommentEnd = cleaned.lastIndexOf("-->")
+		if (lastHtmlCommentEnd !== -1) {
+			cleaned = cleaned.substring(0, lastHtmlCommentEnd).trim()
+		}
+
+		return cleaned.trim()
 	})
 
 	return cleaned.filter((line) => line.length > 0).join("\n")
diff --git a/src/services/ghost/strategies/__tests__/CommentHelpers.test.ts b/src/services/ghost/strategies/__tests__/CommentHelpers.test.ts
new file mode 100644
index 00000000000..f0ab1d45569
--- /dev/null
+++ b/src/services/ghost/strategies/__tests__/CommentHelpers.test.ts
@@ -0,0 +1,325 @@
+import * as vscode from "vscode"
+import { isCommentLine, extractComment, cleanComment } from "../CommentHelpers"
+import { MockTextDocument } from "../../../mocking/MockTextDocument"
+
+describe("CommentHelpers", () => {
+	describe("isCommentLine", () => {
+		describe("empty and whitespace-only comments", () => {
+			test("should reject single-line comment with only syntax", () => {
+				expect(isCommentLine("//", "javascript")).toBe(false)
+			})
+
+			test("should reject single-line comment with only whitespace", () => {
+				expect(isCommentLine("//   ", "javascript")).toBe(false)
+				expect(isCommentLine("#   ", "python")).toBe(false)
+			})
+
+			test("should reject structural multi-line comment markers without content", () => {
+				expect(isCommentLine("/*", "javascript")).toBe(false)
+				expect(isCommentLine("<!--", "html")).toBe(false)
+			})
+
+			test("should reject asterisk-only line (inside block comment)", () => {
+				expect(isCommentLine("*", "javascript")).toBe(false)
+			})
+
+			test("should accept multi-line comment with content", () => {
+				expect(isCommentLine("/* content", "javascript")).toBe(true)
+				expect(isCommentLine("* content", "javascript")).toBe(true)
+				expect(isCommentLine("<!-- content", "html")).toBe(true)
+			})
+
+			test("should reject non-structural multi-line with only whitespace", () => {
+				expect(isCommentLine("*   ", "javascript")).toBe(false)
+			})
+		})
+
+		describe("JavaScript/TypeScript comments", () => {
+			test("should recognize single-line comments with content", () => {
+				expect(isCommentLine("// TODO: fix this", "javascript")).toBe(true)
+				expect(isCommentLine("//TODO: fix this", "javascript")).toBe(true)
+			})
+
+			test("should recognize block comment start", () => {
+				expect(isCommentLine("/* comment", "javascript")).toBe(true)
+			})
+
+			test("should recognize block comment continuation", () => {
+				expect(isCommentLine("* comment", "javascript")).toBe(true)
+			})
+
+			test("should work with TypeScript", () => {
+				expect(isCommentLine("// comment", "typescript")).toBe(true)
+				expect(isCommentLine("/* comment", "typescriptreact")).toBe(true)
+			})
+		})
+
+		describe("Python comments", () => {
+			test("should recognize hash comments", () => {
+				expect(isCommentLine("# comment", "python")).toBe(true)
+			})
+
+			test("should recognize docstring markers", () => {
+				expect(isCommentLine('"""', "python")).toBe(false)
+				expect(isCommentLine("'''", "python")).toBe(false)
+				expect(isCommentLine('""" docstring', "python")).toBe(true)
+				expect(isCommentLine("''' docstring", "python")).toBe(true)
+			})
+
+			test("should handle empty hash comment", () => {
+				expect(isCommentLine("#", "python")).toBe(false)
+			})
+		})
+
+		describe("HTML/XML comments", () => {
+			test("should recognize HTML comment markers", () => {
+				expect(isCommentLine("<!--", "xml")).toBe(false)
+				expect(isCommentLine("<!-- comment", "html")).toBe(true)
+			})
+		})
+
+		describe("CSS comments", () => {
+			test("should recognize CSS block comments", () => {
+				expect(isCommentLine("/* comment", "css")).toBe(true)
+				expect(isCommentLine("* comment", "scss")).toBe(true)
+			})
+
+			test("should recognize single-line comments even in CSS (permissive)", () => {
+				// Permissive: recognize // even in CSS (could be from preprocessor or embedded JS)
+				expect(isCommentLine("// not a comment", "css")).toBe(true)
+			})
+		})
+
+		describe("SQL comments", () => {
+			test("should recognize SQL line comments", () => {
+				expect(isCommentLine("-- comment", "sql")).toBe(true)
+			})
+
+			test("should reject empty SQL comment", () => {
+				expect(isCommentLine("--", "sql")).toBe(false)
+			})
+		})
+
+		describe("other languages", () => {
+			test("should recognize Lisp semicolon comments", () => {
+				expect(isCommentLine("; comment", "lisp")).toBe(true)
+			})
+
+			test("should recognize MATLAB percent comments", () => {
+				expect(isCommentLine("% comment", "matlab")).toBe(true)
+			})
+
+			test("should recognize VB single quote comments", () => {
+				expect(isCommentLine("' comment", "vb")).toBe(true)
+			})
+		})
+
+		describe("edge cases", () => {
+			test("should handle lines with leading whitespace", () => {
+				expect(isCommentLine("  // comment", "javascript")).toBe(true)
+				expect(isCommentLine("\t# comment", "python")).toBe(true)
+			})
+
+			test("should handle mixed comment syntax not matching language", () => {
+				expect(isCommentLine("// comment", "python")).toBe(true)
+				expect(isCommentLine("# comment", "javascript")).toBe(true)
+			})
+
+			test("should reject non-comment lines", () => {
+				expect(isCommentLine("const x = 1", "javascript")).toBe(false)
+				expect(isCommentLine("x = 1", "python")).toBe(false)
+			})
+
+			test("should handle unknown language IDs", () => {
+				expect(isCommentLine("// comment", "unknown")).toBe(true)
+				expect(isCommentLine("# comment", "unknown")).toBe(true)
+			})
+		})
+	})
+
+	describe("extractComment", () => {
+		function createDocument(content: string, languageId: string = "javascript"): MockTextDocument {
+			const uri = vscode.Uri.file("/test.js")
+			const doc = new MockTextDocument(uri, content)
+			doc.languageId = languageId
+			return doc
+		}
+
+		describe("single line comments", () => {
+			test("should extract comment from current line", () => {
+				const doc = createDocument("// comment\nconst x = 1")
+				expect(extractComment(doc, 0)).toBe("// comment")
+			})
+
+			test("should extract comment from previous line if current is not a comment", () => {
+				const doc = createDocument("// comment\nconst x = 1")
+				expect(extractComment(doc, 1)).toBe("// comment")
+			})
+
+			test("should return empty string if no comment found", () => {
+				const doc = createDocument("const x = 1\nconst y = 2")
+				expect(extractComment(doc, 1)).toBe("")
+			})
+
+			test("should not look at previous line if current line is first line", () => {
+				const doc = createDocument("const x = 1")
+				expect(extractComment(doc, 0)).toBe("")
+			})
+		})
+
+		describe("multi-line comments", () => {
+			test("should extract multi-line comment above current line", () => {
+				const doc = createDocument("// line 1\n// line 2\n// line 3\nconst x = 1")
+				const result = extractComment(doc, 2)
+				expect(result).toBe("// line 1\n// line 2\n// line 3")
+			})
+
+			test("should extract multi-line comment below current line", () => {
+				const doc = createDocument("// line 1\n// line 2\n// line 3\nconst x = 1")
+				const result = extractComment(doc, 0)
+				expect(result).toBe("// line 1\n// line 2\n// line 3")
+			})
+
+			test("should extract multi-line comment with cursor in middle", () => {
+				const doc = createDocument("// line 1\n// line 2\n// line 3\nconst x = 1")
+				const result = extractComment(doc, 1)
+				expect(result).toBe("// line 1\n// line 2\n// line 3")
+			})
+
+			test("should handle block comment style", () => {
+				const doc = createDocument("/*\n * line 1\n * line 2\n */\nconst x = 1")
+				const result = extractComment(doc, 1)
+				expect(result).toBe("* line 1\n* line 2\n*/")
+			})
+		})
+
+		describe("Python docstrings", () => {
+			test("should not extract empty Python docstring markers", () => {
+				const doc = createDocument('"""\n"""\n"""\ndef foo():', "python")
+				const result = extractComment(doc, 0)
+				expect(result).toBe("")
+			})
+		})
+
+		describe("edge cases", () => {
+			test("should handle document with only one line", () => {
+				const doc = createDocument("// comment")
+				expect(extractComment(doc, 0)).toBe("// comment")
+			})
+
+			test("should handle comment at end of document", () => {
+				const doc = createDocument("const x = 1\n// comment")
+				expect(extractComment(doc, 1)).toBe("// comment")
+			})
+
+			test("should stop at non-comment line", () => {
+				const doc = createDocument("// comment 1\nconst x = 1\n// comment 2")
+				expect(extractComment(doc, 0)).toBe("// comment 1")
+			})
+
+			test("should handle whitespace-only lines between comments", () => {
+				const doc = createDocument("// comment 1\n   \n// comment 2")
+				expect(extractComment(doc, 0)).toBe("// comment 1")
+			})
+
+			test("should preserve trimmed line content", () => {
+				const doc = createDocument("  // indented comment  \nconst x = 1")
+				expect(extractComment(doc, 0)).toBe("// indented comment")
+			})
+		})
+	})
+
+	describe("cleanComment", () => {
+		describe("JavaScript/TypeScript comments", () => {
+			test("should clean single-line comment", () => {
+				expect(cleanComment("// comment", "javascript")).toBe("comment")
+			})
+
+			test("should clean block comment start", () => {
+				expect(cleanComment("/* comment", "javascript")).toBe("comment")
+			})
+
+			test("should clean block comment end", () => {
+				expect(cleanComment("comment */", "javascript")).toBe("comment")
+			})
+
+			test("should clean asterisk continuation", () => {
+				expect(cleanComment("* comment", "javascript")).toBe("comment")
+			})
+
+			test("should clean full block comment", () => {
+				const comment = "/* comment line 1\n * comment line 2\n * comment line 3\n */"
+				const expected = "comment line 1\ncomment line 2\ncomment line 3"
+				expect(cleanComment(comment, "javascript")).toBe(expected)
+			})
+		})
+
+		describe("Python comments", () => {
+			test("should clean hash comment", () => {
+				expect(cleanComment("# comment", "python")).toBe("comment")
+			})
+
+			test("should clean multi-line hash comments", () => {
+				const comment = "# line 1\n# line 2\n# line 3"
+				const expected = "line 1\nline 2\nline 3"
+				expect(cleanComment(comment, "python")).toBe(expected)
+			})
+
+			test("should NOT clean docstring quotes", () => {
+				const comment = '"""\nDocstring\n"""'
+				const result = cleanComment(comment, "python")
+				expect(result).toContain('"""')
+			})
+		})
+
+		describe("HTML/XML comments", () => {
+			test("should clean HTML comment start", () => {
+				expect(cleanComment("<!-- comment", "html")).toBe("comment")
+			})
+
+			test("should clean HTML comment end", () => {
+				expect(cleanComment("comment -->", "html")).toBe("comment")
+			})
+
+			test("should clean full HTML comment", () => {
+				expect(cleanComment("<!-- comment -->", "html")).toBe("comment")
+			})
+		})
+
+		describe("SQL comments", () => {
+			test("should clean SQL line comment", () => {
+				expect(cleanComment("-- comment", "sql")).toBe("comment")
+			})
+		})
+
+		describe("edge cases", () => {
+			test("should handle empty lines in multi-line comment", () => {
+				const comment = "// line 1\n//\n// line 3"
+				const expected = "line 1\nline 3"
+				expect(cleanComment(comment, "javascript")).toBe(expected)
+			})
+
+			test("should handle mixed comment styles", () => {
+				const comment = "// line 1\n# line 2\n* line 3"
+				const expected = "line 1\nline 2\nline 3"
+				expect(cleanComment(comment, "javascript")).toBe(expected)
+			})
+
+			test("should preserve inner content with comment-like characters", () => {
+				expect(cleanComment("// x = y // z", "javascript")).toBe("x = y // z")
+			})
+
+			test("should handle comment with only whitespace after prefix", () => {
+				expect(cleanComment("//   ", "javascript")).toBe("")
+			})
+
+			test("should handle comment with multiple spaces after prefix", () => {
+				expect(cleanComment("//     comment", "javascript")).toBe("comment")
+			})
+
+			test("should remove trailing block comment end and text after it", () => {
+				expect(cleanComment("/* start */ middle */ end", "javascript")).toBe("start */ middle")
+			})
+		})
+	})
+})