I don't understand the bug you're seeing. Can you provide a full program?
This program prints true twice:

package main

func main() {
	println(test1())
	println(test2())
}

func test1() bool {
	var isFound bool
	var value int64 = 1
	if value == 1 {
		isFound = true
	} else {
		isFound = false
	}
	return isFound
}
func test2() bool {
	var isFound bool
	var value int64 = 1
	if value == int64(1) {
		isFound = true
	} else {
		isFound = false
	}
	return isFound
}

You might also want to read about untyped constants. value == 1 is allowed by the language spec because 1 is an untyped constant and is allowed to be used in comparisons with any numeric type.

I added in interface to my simple code. Now it fails. If I run the example I sent originally, it works.

`package main

import (
"fmt"
)

type junk interface {
getkey() string
getvalue() int64
}

type stuff struct{}

func (s stuff) getkey() string {
return "housekey"
}

func (s stuff) getvalue() int64 {
return 1
}

type stuffFactory func() junk

func createStuff() junk {
return stuff{}
}

type item struct {
key string
value int64
}

func (i item) getkey() string {
return i.key
}

func (i item) getvalue() interface{} {
return i.value
}

func main() {
myitem := item{key:"Gettysburg", value: 1}

value := myitem.getvalue()

fmt.Printf("value = %v\n", value)
fmt.Println("test if statement with int64 and literal")
fmt.Printf("value is of type %T, 1 is of type %T\n", value, 1)

if value == 1 {
    fmt.Println("value is true")
} else {
    fmt.Println("value is false")
}

}`

Running this program gives this output:

bash-4.2$ go run main.go
value = 1
test if statement with int64 and literal
value is of type int64, 1 is of type int
value is false

I don't see a bug here, so closing. You may want to take a look at https://blog.golang.org/constants.

var x, y int64
var i, j interface{}
a := x == y
b := i == j
c := i == x

The first comparison compares the values of the variables x and y, as expected.
The second comparison compares both the types and the values of i and j. Both the type and the value have to match, for the equality to be true.
The third comparison is really this: i == (interface{})(x). That is, the concrete type is promoted to an interface before the equality check. Thus, the third comparison compares both the types and values. In this case, the type of x is int64, so an int64 must be in i for the equality to be true.

When you do

var x interface{} = int64(1)
a := x == 1

That 1 on the RHS must be converted to an interface before the equality check is done. Because 1 is a Go constant, it gets the default type for integer constants, which is int. Then when the comparison happens, it returns false because the types don't match (int64 and int are not the same type).

Shouldn't the compiler at least flag this as a type mismatch?

I'm not sure what you think the compiler should do. There are several different test cases in this issue. Can you provide a specific example where you think the compiler should behave differently?