knowledge-base/kb

#!/usr/bin/env bash

# Dependencies
# * bash (includes bash extentions that are not in posix shell eg [[ ]]
# * sqlite3
# * sed
# * awk
# * tr
# * git
# * yq (https://github.com/kislyuk/yq)
# * fzf (https://github.com/junegunn/fzf)
# * rg (https://github.com/BurntSushi/ripgrep)
# * bat (https://github.com/sharkdp/bat)



# Colour definitions
RED='\033[1;31m'
GREEN='\033[1;32m'
YELLOW='\033[1;33m'
NC='\033[0m'

# Provide a variable with the location of this script.
#scriptPath="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"


# Utility functions
# ##################################################

die(){
	necho -e "${RED}$*${NC}" >&2
	exit 1
}

# Normal echo
# Echo if quiet is 0
necho(){
	if [ "$quiet" -eq 0 ]; then
		echo "$@"
	fi
}

# verbose echo
# Echo if verbose is 1
vecho(){
	if [ "$verbose" -eq 1 ]; then
		echo "$@"
	fi
}

# Exits after any cleanup that may be needed
safeExit(){
	# TODO: Add cleanup
	exit 0
}


isInt() {
	[ "$1" -eq "$1" ] 2> /dev/null
	return "$?"
}


# Set Flags
# -----------------------------------
# Flags which can be overridden by user input.
# Default values are below
# -----------------------------------
quiet=0
verbose=0
debug=0
dogit=1
args=()
dataDir="${XDG_DATA_HOME:=$HOME/.local/share}/kb/"
sqliteFile=""
editor="${EDITOR:=vim}"

# Check for Dependencies
# -----------------------------------
# Arrays containing package dependencies needed to execute this script.
# The script will fail if dependencies are not installed.
# -----------------------------------
checkDependencies(){
	local dependencies=(
		"sqlite3"
		"rg"
		"fzf"
		"sed"
		"awk"
		"tr"
		"git"
		"yq"
		"bat"
	)
	local ret=0
	for program in "${dependencies[@]}"; do
		if ! type "$program" &>/dev/null; then
			necho -e "${RED}$program is not installed${NC}"
			ret=1
			case "$program" in
				"rg")
					necho -e "\t${YELLOW}This provides effecient searching${NC}"
					;;
				"fzf")
					necho -e "\t${YELLOW}This provides fuzzy searching${NC}"
					;;

			esac
		fi
	done
	return $ret
}

initKnowledgeBase(){
	local output
	necho -e "${YELLOW}Initialising Knowledge base${NC}"
	vecho "Directory: $dataDir"
	if [ "$verbose" -gt 0 ]; then
		output="/dev/stdout"
	else
		output="/dev/null"
	fi
	[ -e "$dataDir" ]  && die "$dataDir already exists"
	mkdir -p "$dataDir"
	if [ "$dogit" -gt 0 ]; then
		git init "$dataDir" > "$output"
		
		# TODO: make gitignore use new sqlite file
		echo "/knowledgebase.sqlite3" >> "${dataDir}/.gitignore"

		git -C "$dataDir" add .gitignore > "$output"
		git -C "$dataDir" commit -m "Knowledge base initialised" > output
	fi
	vecho "Creating Database"
	echo 'CREATE TABLE items
	(id integer primary key, filename text, title text, type text);
	CREATE TABLE tags
	(id integer primary key, name text);
	CREATE TABLE links
	(id integer primary key, itemID integer, tagID integer); ' |
	sqlite3 "${sqliteFile}"
	necho -e "${GREEN}Initialised Knowledge base${NC}"
}

# This will create a fresh database based on the files in the folder
makedb(){
	[ -f "$sqliteFile" ] && die "sqlite file already exists\ndelete it first if you want to"
	echo "Still need to implement this"
}

getYamlBlock(){
	vecho "getYamlBlock $*"
	cd "$dataDir" || return
	local filename
	filename="$(findFile "$1")"

	sed -n '1 { /^---/ { :a N; /\n---/! ba; p} }' "$filename" |
		sed '1d;$d;s/\t/    /g'
}

getYamlTitle(){
	vecho "getYamlTitle $*"
	cd "$dataDir" || return
	getYamlBlock "$1" | yq -r '.Title'
}

getYamlTags(){
	vecho "getYamlTitle $*"
	cd "$dataDir" || return
	getYamlBlock "$1" | yq -r '.Tags | join("\n")'
}

# Makes file names safe
escapeFilename(){
	vecho "escapeFilename $*"
	echo "$1" |
		tr ' ' '_' | # replace spaces with underscores
		tr -d '/' # Delete slashes
}

findFileId(){
	local filename
	filename="$(findFile "$1")"
	[ ! -e "$filename" ] && exit 1
	echo "SELECT id FROM items WHERE filename = '$(safeSQL "$filename")'" |
		sqlite3 "${sqliteFile}"

}

# Escapes ' and \ characters
safeSQL(){
	echo "$1" |
		sed 's/\\/\\\\/g' |
		sed "s/'/\\\'/g"
}


assignTags(){
	local filename
	local tags
	local tagIDs
	local tagIDsOr
	local fileID
	filename="$(findFile "$1")"
	[ ! -e "$filename" ] && exit 1
	tags="$(cat - | sed '/^$/d')"
	fileID="$(findFileId "$filename")"
	# If there are tags
	if [ -n "$tags" ]; then
		local values
		local orlist
		while read -r line; do
			values+=",('$(safeSQL "$line")')"
			orlist+=" OR name = '$(safeSQL "$line")'"
		done <<<"$(echo "$tags")"
		values="$(echo "$values" | sed 's/^,//')"
		orlist="$(echo "$orlist" | sed 's/^ OR //')"
		
		# Ensure that all the tags exist
		echo "INSERT INTO tags (name) VALUES $values
			EXCEPT SELECT name FROM tags;" |
				sqlite3 "${sqliteFile}"

		# Get the tag ids we need to assosiate with the current file
		tagIDs="$(echo "SELECT id FROM tags WHERE $orlist" |
			sqlite3 "${sqliteFile}")"
		
		#Loop through them all
		while read -r tagID; do
			tagIDsOr+=" OR tagID = $(safeSQL "$tagID")"
			
			# Check the tag is already linkded with the file
			local existing
			existing="$(echo "SELECT id FROM links
				WHERE itemID = $(safeSQL "$fileID")
				AND tagID = $(safeSQL "$tagID")" |
				sqlite3 "${sqliteFile}"
			)"

			# If not, add a link
			if [ -z "$existing" ]; then
				echo "INSERT INTO links (itemID,tagID)
				VALUES ($(safeSQL "$fileID"),$(safeSQL "$tagID"))" |
				sqlite3 "${sqliteFile}"
			fi
		done <<<"$(echo "$tagIDs")"
		tagIDsOr="$(echo "$tagIDsOr" | sed 's/^ OR //')"

		# Delete any links that are not in the list
		echo "DELETE FROM links
		WHERE itemID = $(safeSQL "$fileID")
		AND NOT ( $tagIDsOr )" |
		sqlite3 "${sqliteFile}"

	else # If there are no tags, simply delete any that are referenced
		echo "DELETE FROM links WHERE itemID = '$(safeSQL "$fileID")'" |
			sqlite3 "${sqliteFile}"
	fi
	

}

newFile(){
	vecho "newFile $*"
	cd "$dataDir" || return
	# While there is a - at the begining
	local title="$*"
	if [ -z "$title" ]; then
		echo -n "Enter a title: "
		read -r title
	fi
	local filename
	filename="$(escapeFilename "$title.md")"
	[ -e "$filename" ] && die "$filename already exists"
	echo -e "---
Title: $title
Tags:
	-
---
" > "$filename"
	echo "INSERT INTO items (filename, title, type)
	VALUES ( '$(safeSQL "$filename")', '$(safeSQL "$title")', 'normal' );" |
		sqlite3 "${sqliteFile}"
	editFile "$filename"
}

findFile(){
	vecho "findFile $*"
	cd "$dataDir" || return
	local filename

	if [ "$#" -eq 1 ] && isInt "$1"; then
		filename="$(echo "SELECT filename
		FROM items WHERE id = '$(safeSQL "$1")'" |
			sqlite3 "${sqliteFile}")"
	fi

	[ -z "$filename" ] && filename="$(escapeFilename "$*")"
	if [ -e "$filename" ]; then
		# If the file exists, return it
		echo "$filename"
		exit 0
	else
		# If it exists with .md at the end, assume that was meant
		# otherwise die
		if [ -e "$filename.md" ]; then
			echo "$filename.md"
			exit 0
		else
			die "No such file or ID $filename"
			exit 1
		fi
	fi
}

dogit(){
	cd "$dataDir" || return
	git "$@"
}

# This function will add and commit a file after it has been edited
gitChange(){
	cd "$dataDir" || return
	local filename="$1"
	if [ "$dogit" -gt 0 ]; then
		if [ -f "$filename" ]; then
			if ! git diff --exit-code "$filename" > /dev/null 2>&1; then
				# Changes
				git add "$filename"
				git commit -m "KB auto-commit: Updated: $filename"
			elif ! git ls-files --error-unmatch "$filename" > /dev/null 2>&1; then
				# New file
				git add "$filename"
				git commit -m "KB auto-commit: New: $filename"
			fi
		fi
	fi
}

# Takes the filename as a parameter
editFile(){
	vecho "editFile $*"
	cd "$dataDir" || return
	local filename
	local oldTitle
	local newTitle
	filename="$(findFile "$*")"
	[ ! -e "$filename" ] && exit 1
	oldTitle="$(getYamlTitle "$filename")"
	"$editor" "$filename"
	newTitle="$(getYamlTitle "$filename")"
	getYamlTags "$filename" | assignTags "$filename"
	if [ "$newTitle" != "$oldTitle" ]; then
		vecho "Changed title"
		local newfilename
		newfilename="$(escapeFilename "$newTitle.md")"
		if [ -e "$newfilename" ]; then
			echo -e "${YELLOW}File name $newfilename already exists${NC}"
			echo -e "Please fix manually"
			exit 1
		else
			mv "$filename" "$newfilename"
			echo "UPDATE items
				SET (filename,title) = ('$(safeSQL "$newfilename")','$(safeSQL "$newTitle")')
				WHERE filename = '$(safeSQL "$filename")';" |
				sqlite3 "${sqliteFile}"
			gitChange "$newfilename"
		fi
	else
		gitChange "$filename"
	fi
}

listEntries(){
	vecho "listEntries $*"
	cd "$dataDir" || return
	echo "SELECT items.id,items.filename,items.title,items.type,
	GROUP_CONCAT(tags.name,',') tags
	FROM items LEFT JOIN links ON items.id = links.itemID
	LEFT JOIN tags ON links.tagID = tags.id
	GROUP BY items.id;" |
		sqlite3 --column --header "${sqliteFile}"
}

fuzzySelect(){
	cd "$dataDir" || return
	local id
	export -f fzfPreview
	export dataDir
	id="$(listEntries | fzf --header-lines=2 --delimiter="  +" --with-nth=3,5 \
		--preview='bash -c "fzfPreview {}"' | awk '{print $1}')"
	if [ -n "$id" ]; then
		case "$1" in
			edit) editFile "$id"; safeExit ;;
			view) viewFile "$id"; safeExit ;;
		esac
	fi
}

fzfPreview(){
	cd "$dataDir" || return

	local id
	local filename
	local title
	local type
	local tags

	id="$(echo "$1" | awk -F '  +' '{print $1}')"
	filename="$(echo "$1" | awk -F '  +' '{print $2}')"
	title="$(echo "$1" | awk -F '  +' '{print $3}')"
	type="$(echo "$1" | awk -F '  +' '{print $4}')"
	tags="$(echo "$1" | awk -F '  +' '{print $5}')"

	if [ "$type" = "normal" ]; then
		bat --color=always --style=numbers "$filename"
	fi
}

viewFile(){
	cd "$dataDir" || return

	local id="$1"
	local filename

	filename="$(findFile "$id")"

	bat --color=always --style=full "$filename"
}

deleteFile(){
	cd "$dataDir" || return
	local filename
	local fileID
	local rsp
	filename="$(findFile "$1")"
	fileID="$(findFileId "$filename")"
	[ ! -e "$filename" ] && exit 1
	echo -n "Are you sure? [yN] "
	read -r rsp
	if [[ "$(echo "$rsp" | tr '[:upper:]' '[:lower:]')" = "y"* ]]; then
		rm "$filename"
		# This deletes the file from the sql database and any tag links
		echo "DELETE FROM items
			WHERE id = '$(safeSQL "$fileID")';
			DELETE FROM links
			WHERE itemID = '$(safeSQL "$fileID")';" |
			sqlite3 --column --header "${sqliteFile}"
	fi
}

doDeepSearch(){
	cd "$dataDir" || return
	local query="$1"
	echo "$query"
	rg --column --line-number --no-heading --color=always --smart-case "$query"
}

doDeepPreview(){
	cd "$dataDir" || return
	local file
	local line
	file="$(echo "$1" | cut -d ':' -f 1)"
	line="$(echo "$1" | cut -d ':' -f 2)"
	bat --color=always --style=numbers -H "$line" "$file"
}

deepSearch(){
	type -p rg > /dev/null || die "You need rg installed for deep search"
	export -f doDeepSearch
	export -f doDeepPreview
	export dataDir
	echo "" | fzf --ansi \
		--bind 'change:reload:bash -c "doDeepSearch {q} || true"' \
		--preview 'bash -c "doDeepPreview {} || true"'
}

mainScript() {
	############## Begin Script Here ###################
	####################################################
	if [ "${args[0]}" != "init" ]; then
		cd "$dataDir" || return
		# Check to see if datadir is a git repo
		if git rev-parse 2> /dev/null; then
			# If not, ensure we don't run git commands
			dogit=0
		fi
	fi
	case "${args[0]}" in
		init) initKnowledgeBase; safeExit ;;
		makedb) makedb; safeExit ;;
		new) newFile "${args[@]:1}"; safeExit ;;
		edit) editFile "${args[@]:1}"; safeExit ;;
		list) listEntries "${args[@]:1}"; safeExit ;;
		view) viewFile "${args[@]:1}"; safeExit ;;
		fuzzy) fuzzySelect "${args[@]:1}"; safeExit ;;
		deepsearch) deepSearch "${args[@]:1}"; safeExit ;;
		del|delete) deleteFile "${args[@]:1}"; safeExit ;;
		git) dogit "${args[@]:1}"; safeExit ;;
		*) usage >&2; safeExit ;;
	esac


	####################################################
	############### End Script Here ####################
}

############## Begin Options and Usage ###################


# Print usage
usage() {
	echo -n "kb [OPTIONS]... COMMAND

	Knowledge Base Management

	This tool helps manage my personal knowledge base

	Options:
	-q, --quiet             Quiet (no output)
	-v, --verbose           Output more information. (Items echoed to 'verbose')
	-d, --debug             Runs script in BASH debug mode (set -x)
	-h, --help              Display this help and exit
	--data <directory>      The knowledgebase data dir
	--sqlite <file>         The sqlite file (default to <data>/knowledgebase.sqlite3
	--nogit                 Don't run git commands
	--version               Output version information and exit

	Commands:
	init                    Initialise a new knowledgebase
	new [options] [title]   Create new entry
		--filetype <type>   Type of file ( default md)
	edit [title]            Edit a file
	list                    List all files
	view                    View a file
	fuzzy [command]         Fuzzy select a file
		command is what to do with the selected file
		edit or view
	git [options]           Run arbitary git commands on the kb repository
	del [title]             Delete a file
"
}

# Iterate over options breaking -ab into -a -b when needed and --foo=bar into
# --foo bar
optstring=h
unset options
while (($#)); do
	case $1 in
		# If option is of type -ab
		-[!-]?*)
		# Loop over each character starting with the second
		for ((i=1; i < ${#1}; i++)); do
			c=${1:i:1}

			# Add current char to options
			options+=("-$c")

			# If option takes a required argument, and it's not the last char make
			# the rest of the string its argument
			if [[ $optstring = *"$c:"* && ${1:i+1} ]]; then
				options+=("${1:i+1}")
				break
			fi
		done
		;;

		# If option is of type --foo=bar
		--?*=*) options+=("${1%%=*}" "${1#*=}") ;;
		# add --endopts for --
		--) options+=(--endopts) ;;
		# Otherwise, nothing special
		*) options+=("$1") ;;
	esac
	shift
done
set -- "${options[@]}"
unset options

# Print help if no arguments were passed.
# Uncomment to force arguments when invoking the script
[[ $# -eq 0 ]] && set -- "--help"

# Read the options and set stuff
while [[ $1 = -?* ]]; do
	case $1 in
		-h|--help) usage >&2; safeExit ;;
		-v|--verbose) verbose=1 ;;
		-q|--quiet) quiet=1 ;;
		-d|--debug) debug=1;;
		--data) dataDir="$2"; shift ;;
		--sqlite) sqliteFile="$2"; shift ;;
		--editor) editor="$2"; shift ;;
		--nogit) dogit=0 ;;
		--) shift; break ;;
		*) die "invalid option: '$1'." ;;
	esac
	shift
done

# If the sqlite file hasn't been specified on the command line, make it a file
# called knowledgebase.sqlite3 in the dataDir
[ -z "$sqliteFile" ] && sqliteFile="${dataDir}/knowledgebase.sqlite3"

# Store the remaining part as arguments.
args+=("$@")

############## End Options and Usage ###################




# ############# ############# #############
# ##       TIME TO RUN THE SCRIPT        ##
# ##                                     ##
# ## You shouldn't need to edit anything ##
# ## beneath this line                   ##
# ##                                     ##
# ############# ############# #############

# Exit on error. Append '||true' when you run the script if you expect an error.
set -o errexit

# Run in debug mode, if set
if [ "${debug}" == "1" ]; then
	set -x
fi

# Bash will remember & return the highest exitcode in a chain of pipes.
# This way you can catch the error in case mysqldump fails in `mysqldump |gzip`, for example.
set -o pipefail

# Invoke the checkDependencies function to test for Bash packages
checkDependencies


# Run your script
mainScript

safeExit # Exit cleanly

[ -n "$KB_DIR" ] && dataDir="$KB_DIR" ||
	dataDir="${XDG_DATA_HOME:=$HOME/.local/share}/kb/"

mkdir -p "$dataDir"