Packages
fnord
0.4.41
0.9.40
0.9.39
0.9.38
0.9.37
0.9.36
0.9.35
0.9.34
0.9.33
0.9.32
0.9.31
0.9.30
0.9.29
0.9.28
0.9.27
0.9.26
0.9.25
0.9.24
0.9.23
0.9.22
0.9.21
0.9.20
0.9.19
0.9.18
0.9.17
0.9.16
0.9.15
0.9.14
0.9.13
0.9.12
0.9.11
0.9.10
0.9.9
0.9.8
0.9.7
0.9.6
0.9.5
0.9.4
0.9.3
0.9.2
0.9.1
0.9.0
0.8.99
0.8.98
0.8.97
0.8.96
0.8.95
0.8.94
0.8.93
0.8.92
0.8.91
0.8.90
0.8.89
0.8.88
0.8.87
0.8.86
0.8.85
0.8.84
0.8.83
0.8.82
0.8.81
0.8.80
0.8.79
0.8.78
0.8.77
0.8.76
0.8.75
0.8.74
0.8.73
0.8.72
0.8.71
0.8.70
0.8.69
0.8.68
0.8.67
0.8.66
0.8.65
0.8.64
0.8.63
0.8.62
0.8.61
0.8.60
0.8.59
0.8.58
0.8.57
0.8.56
0.8.55
0.8.54
0.8.53
0.8.52
0.8.51
0.8.50
0.8.49
0.8.48
0.8.47
0.8.46
0.8.45
0.8.44
0.8.43
0.8.42
0.8.41
0.8.40
0.8.39
0.8.38
0.8.37
0.8.36
0.8.35
0.8.34
0.8.33
0.8.32
0.8.31
0.8.30
0.8.29
0.8.27
0.8.26
0.8.25
0.8.24
0.8.23
0.8.22
0.8.21
0.8.20
0.8.19
0.8.18
0.8.17
0.8.16
0.8.15
0.8.14
0.8.13
0.8.12
0.8.11
0.8.1
0.8.0
0.7.24
0.7.23
0.7.22
0.7.21
0.7.20
0.7.19
0.7.18
0.7.17
0.7.16
0.7.15
0.7.14
0.7.13
0.7.12
0.7.11
0.7.10
0.7.9
0.7.8
0.7.7
0.7.6
0.7.5
0.7.3
0.7.2
0.7.1
0.7.0
0.6.9
0.6.8
0.6.7
0.6.6
0.6.5
0.6.4
0.6.3
0.6.1
0.6.0
0.5.9
0.5.8
0.5.7
0.5.6
0.5.5
0.5.4
0.5.3
0.5.2
0.5.1
0.5.0
0.4.44
0.4.43
0.4.42
0.4.41
0.4.40
0.4.39
0.4.38
0.4.37
0.4.36
0.4.35
0.4.34
0.4.33
0.4.32
0.4.30
0.4.29
0.4.28
0.4.27
0.4.26
0.4.25
0.4.24
0.4.23
0.4.22
0.4.21
0.4.20
0.4.19
0.4.18
0.4.17
0.4.16
0.4.15
0.4.14
0.4.13
0.4.12
0.4.11
0.4.10
0.4.9
0.4.8
0.4.7
0.4.6
0.4.5
0.4.4
0.4.3
0.4.2
0.4.1
0.4.0
0.3.0
0.2.0
0.1.0
AI code archaeology
Current section
Files
Jump to
Current section
Files
lib/store/entry.ex
defmodule Store.Entry do
defstruct [
:project,
:file,
:rel_path,
:key,
:store_path,
:metadata,
:summary,
:outline,
:embeddings
]
def new_from_file_path(project, file) do
abs_path = file |> Store.Project.expand_path(project)
rel_path = abs_path |> Store.Project.relative_path(project)
key = key(abs_path)
store_path = Path.join(project.store_path, key)
metadata = Store.Metadata.new(store_path, abs_path)
summary = Store.Summary.new(store_path, abs_path)
outline = Store.Outline.new(store_path, abs_path)
embeddings = Store.Embeddings.new(store_path, abs_path)
%__MODULE__{
project: project,
file: abs_path,
rel_path: rel_path,
key: key,
store_path: store_path,
metadata: metadata,
summary: summary,
outline: outline,
embeddings: embeddings
}
end
def new_from_entry_path(project, entry_path) do
file_path =
entry_path
|> Path.join("metadata.json")
|> File.read!()
|> Jason.decode!()
|> Map.get("file")
new_from_file_path(project, file_path)
end
def source_file_exists?(entry) do
cond do
!File.exists?(entry.file) -> false
Git.is_ignored?(entry.file) -> false
true -> true
end
end
def exists_in_store?(entry) do
File.dir?(entry.store_path)
end
def is_git_ignored?(entry) do
Git.is_ignored?(entry.file)
end
def create(entry), do: File.mkdir_p!(entry.store_path)
def delete(entry), do: File.rm_rf!(entry.store_path)
def is_incomplete(entry) do
cond do
!has_metadata?(entry) -> true
!has_summary?(entry) -> true
!has_outline?(entry) -> true
!has_embeddings?(entry) -> true
true -> false
end
end
def is_stale?(entry) do
# Files that are missing or have missing indexes must be reindexed.
!exists_in_store?(entry) ||
is_incomplete(entry) ||
!hash_is_current?(entry)
end
def hash_is_current?(entry) do
with {:ok, hash} <- get_last_hash(entry) do
hash == file_sha256(entry.file)
else
_ -> false
end
end
def read_source_file(entry), do: File.read(entry.file)
def read(entry) do
with {:ok, metadata} <- read_metadata(entry),
{:ok, summary} <- read_summary(entry),
{:ok, outline} <- read_outline(entry),
{:ok, embeddings} <- read_embeddings(entry) do
info =
metadata
|> Map.put(:summary, summary)
|> Map.put(:outline, outline)
|> Map.put(:embeddings, embeddings)
{:ok, info}
end
end
def save(entry, summary, outline, embeddings) do
delete(entry)
create(entry)
with :ok <- save_metadata(entry),
:ok <- save_summary(entry, summary),
:ok <- save_outline(entry, outline),
:ok <- save_embeddings(entry, embeddings) do
:ok
end
end
# -----------------------------------------------------------------------------
# metadata.json
# -----------------------------------------------------------------------------
def metadata_file_path(entry), do: Store.Metadata.store_path(entry.metadata)
def has_metadata?(entry), do: Store.Metadata.exists?(entry.metadata)
def read_metadata(entry), do: Store.Metadata.read(entry.metadata)
def save_metadata(entry), do: Store.Metadata.write(entry.metadata, nil)
# -----------------------------------------------------------------------------
# summary
# -----------------------------------------------------------------------------
def summary_file_path(entry), do: Store.Summary.store_path(entry.summary)
def has_summary?(entry), do: Store.Summary.exists?(entry.summary)
def read_summary(entry), do: Store.Summary.read(entry.summary)
def save_summary(entry, data), do: Store.Summary.write(entry.summary, data)
# -----------------------------------------------------------------------------
# outline
# -----------------------------------------------------------------------------
def outline_file_path(entry), do: Store.Outline.store_path(entry.outline)
def has_outline?(entry), do: Store.Outline.exists?(entry.outline)
def read_outline(entry), do: Store.Outline.read(entry.outline)
def save_outline(entry, data), do: Store.Outline.write(entry.outline, data)
# -----------------------------------------------------------------------------
# embeddings
# -----------------------------------------------------------------------------
def embeddings_file_paths(entry), do: Store.Embeddings.store_path(entry.embeddings)
def has_embeddings?(entry), do: Store.Embeddings.exists?(entry.embeddings)
def read_embeddings(entry), do: Store.Embeddings.read(entry.embeddings)
def save_embeddings(entry, embeddings), do: Store.Embeddings.write(entry.embeddings, embeddings)
# -----------------------------------------------------------------------------
# misc
# -----------------------------------------------------------------------------
@doc """
Embeddings used to be stored as multiple files, one for each
context-window-sized file chunk. Now we combine them. This section attempts
to detect the old embeddings style and correct them.
"""
def fix_old_embeddings(entry) do
entry.store_path
|> Path.join("embeddings_*.json")
|> Path.wildcard()
end
# -----------------------------------------------------------------------------
# Private functions
# -----------------------------------------------------------------------------
defp get_last_hash(entry) do
with {:ok, metadata} <- read_metadata(entry) do
Map.fetch(metadata, "hash")
end
end
defp key(file_path), do: sha256(file_path)
defp file_sha256(file_path) do
case File.read(file_path) do
{:ok, content} -> sha256(content)
{:error, reason} -> {:error, reason}
end
end
defp sha256(content) do
:crypto.hash(:sha256, content) |> Base.encode16(case: :lower)
end
end