diff --git a/.gitignore b/.gitignore
index 89e8265..4f264e5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,7 @@ __pycache__/
 *.so
 
 # Distribution / packaging
+/.env/
 .Python
 env/
 build/
@@ -24,6 +25,9 @@ var/
 .installed.cfg
 *.egg
 
+# IDE's
+/.idea
+
 # Installer logs
 pip-log.txt
 pip-delete-this-directory.txt
diff --git a/setup.py b/setup.py
index 013e357..9d224b7 100755
--- a/setup.py
+++ b/setup.py
@@ -1,8 +1,8 @@
 #!/usr/bin/env python
 import io
 import sys
-
 from setuptools import find_packages, setup
+import ti
 
 
 def read(*filenames, **kwargs):
@@ -18,21 +18,27 @@ def read(*filenames, **kwargs):
 
 setup(
     name="ti",
-    version="0.1.1.dev0",
-    author="Shrikant Sharat",
-    author_email="shrikantsharat.k@gmail.com",
+    version=ti.__version__,
+    author="Shrikant Sharat, Trevor Bekolay, Eduard Kracmar",
+    author_email="shrikantsharat.k@gmail.com, tbekolay@gmail.com, eduard@adaptiware.com",
     packages=find_packages(),
     include_package_data=True,
     scripts=[],
-    url="http://ti.sharats.me/",
+    url="https://github.com/tbekolay/ti",
     description="A silly simple time tracker",
     long_description=read('README.rst', 'CHANGES.rst'),
     entry_points={
         'console_scripts': [
-            'ti = ti:main',
+            'ti = ti.ti:main',
         ]
     },
-    install_requires=["colorama", "pyyaml"],
+    install_requires=[
+        "colorama",
+        "PyYAML",
+        "tabulate",
+        "pendulum==0.5.5",
+        "pytimeparse",
+    ],
     setup_requires=["pytest-runner"] if testing else [],
     tests_require=["pytest", "cram", "pytest-cram"],
     extras_require={
diff --git a/ti/__init__.py b/ti/__init__.py
index 483736f..1d4f2cd 100755
--- a/ti/__init__.py
+++ b/ti/__init__.py
@@ -1,46 +1,8 @@
 # coding: utf-8
-
-"""
-ti is a simple and extensible time tracker for the command line. Visit the
-project page (http://ti.sharats.me) for more details.
-
-Usage:
-  ti (o|on) <name> [<time>...]
-  ti (f|fin) [<time>...]
-  ti (s|status)
-  ti (t|tag) <tag>...
-  ti (n|note) <note-text>...
-  ti (l|log) [today]
-  ti (e|edit)
-  ti (i|interrupt)
-  ti --no-color
-  ti -h | --help
-
-Options:
-  -h --help         Show this help.
-  <start-time>...   A time specification (goto http://ti.sharats.me for more on
-                    this).
-  <tag>...          Tags can be made of any characters, but its probably a good
-                    idea to avoid whitespace.
-  <note-text>...    Some arbitrary text to be added as `notes` to the currently
-                    working project.
-"""
-
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import json
 import os
-import re
-import subprocess
-import sys
-import tempfile
-from datetime import datetime, timedelta
-from collections import defaultdict
-from os import path
+import json
 
-import yaml
-from colorama import Fore
+__version__ = '0.1.1.dev2'
 
 
 class JsonStore(object):
@@ -50,7 +12,7 @@ def __init__(self, filename):
 
     def load(self):
 
-        if path.exists(self.filename):
+        if os.path.exists(self.filename):
             with open(self.filename) as f:
                 data = json.load(f)
 
@@ -64,381 +26,4 @@ def dump(self, data):
             json.dump(data, f, separators=(',', ': '), indent=2)
 
 
-def red(str):
-    if use_color:
-        return Fore.RED + str + Fore.RESET
-    else:
-        return str
-
-
-def green(str):
-    if use_color:
-        return Fore.GREEN + str + Fore.RESET
-    else:
-        return str
-
-
-def yellow(str):
-    if use_color:
-        return Fore.YELLOW + str + Fore.RESET
-    else:
-        return str
-
-
-def blue(str):
-    if use_color:
-        return Fore.BLUE + str + Fore.RESET
-    else:
-        return str
-
-
-def action_on(name, time):
-    data = store.load()
-    work = data['work']
-
-    if work and 'end' not in work[-1]:
-        print('You are already working on ' + yellow(work[-1]['name']) +
-              '. Stop it or use a different sheet.', file=sys.stderr)
-        raise SystemExit(1)
-
-    entry = {
-        'name': name,
-        'start': time,
-    }
-
-    work.append(entry)
-    store.dump(data)
-
-    print('Start working on ' + green(name) + '.')
-
-
-def action_fin(time, back_from_interrupt=True):
-    ensure_working()
-
-    data = store.load()
-
-    current = data['work'][-1]
-    current['end'] = time
-    store.dump(data)
-    print('So you stopped working on ' + red(current['name']) + '.')
-
-    if back_from_interrupt and len(data['interrupt_stack']) > 0:
-        name = data['interrupt_stack'].pop()['name']
-        store.dump(data)
-        action_on(name, time)
-        if len(data['interrupt_stack']) > 0:
-            print('You are now %d deep in interrupts.'
-                  % len(data['interrupt_stack']))
-        else:
-            print('Congrats, you\'re out of interrupts!')
-
-
-def action_interrupt(name, time):
-    ensure_working()
-
-    action_fin(time, back_from_interrupt=False)
-
-    data = store.load()
-    if 'interrupt_stack' not in data:
-        data['interrupt_stack'] = []
-    interrupt_stack = data['interrupt_stack']
-
-    interrupted = data['work'][-1]
-    interrupt_stack.append(interrupted)
-    store.dump(data)
-
-    action_on('interrupt: ' + green(name), time)
-    print('You are now %d deep in interrupts.' % len(interrupt_stack))
-
-
-def action_note(content):
-    ensure_working()
-
-    data = store.load()
-    current = data['work'][-1]
-
-    if 'notes' not in current:
-        current['notes'] = [content]
-    else:
-        current['notes'].append(content)
-
-    store.dump(data)
-
-    print('Yep, noted to ' + yellow(current['name']) + '.')
-
-
-def action_tag(tags):
-    ensure_working()
-
-    data = store.load()
-    current = data['work'][-1]
-
-    current['tags'] = set(current.get('tags') or [])
-    current['tags'].update(tags)
-    current['tags'] = list(current['tags'])
-
-    store.dump(data)
-
-    tag_count = str(len(tags))
-    print('Okay, tagged current work with ' + tag_count + ' tag' +
-          ('s' if tag_count > 1 else '') + '.')
-
-
-def action_status():
-    try:
-        ensure_working()
-    except SystemExit(1):
-        return
-
-    data = store.load()
-    current = data['work'][-1]
-
-    start_time = parse_isotime(current['start'])
-    diff = timegap(start_time, datetime.utcnow())
-
-    print('You have been working on {0} for {1}.'.format(
-        green(current['name']), diff))
-
-
-def action_log(period):
-    data = store.load()
-    work = data['work'] + data['interrupt_stack']
-    log = defaultdict(lambda: {'delta': timedelta()})
-    current = None
-
-    for item in work:
-        start_time = parse_isotime(item['start'])
-        if 'end' in item:
-            log[item['name']]['delta'] += (
-                parse_isotime(item['end']) - start_time)
-        else:
-            log[item['name']]['delta'] += datetime.utcnow() - start_time
-            current = item['name']
-
-    name_col_len = 0
-
-    for name, item in log.items():
-        name_col_len = max(name_col_len, len(name))
-
-        secs = item['delta'].seconds
-        tmsg = []
-
-        if secs > 3600:
-            hours = int(secs / 3600)
-            secs -= hours * 3600
-            tmsg.append(str(hours) + ' hour' + ('s' if hours > 1 else ''))
-
-        if secs > 60:
-            mins = int(secs / 60)
-            secs -= mins * 60
-            tmsg.append(str(mins) + ' minute' + ('s' if mins > 1 else ''))
-
-        if secs:
-            tmsg.append(str(secs) + ' second' + ('s' if secs > 1 else ''))
-
-        log[name]['tmsg'] = ', '.join(tmsg)[::-1].replace(',', '& ', 1)[::-1]
-
-    for name, item in sorted(log.items(), key=(lambda x: x[1]), reverse=True):
-        print(name.ljust(name_col_len), ' ∙∙ ', item['tmsg'],
-              end=' ← working\n' if current == name else '\n')
-
-
-def action_edit():
-    if 'EDITOR' not in os.environ:
-        print("Please set the 'EDITOR' environment variable", file=sys.stderr)
-        raise SystemExit(1)
-
-    data = store.load()
-    yml = yaml.safe_dump(data, default_flow_style=False, allow_unicode=True)
-
-    cmd = os.getenv('EDITOR')
-    fd, temp_path = tempfile.mkstemp(prefix='ti.')
-    with open(temp_path, "r+") as f:
-        f.write(yml.replace('\n- ', '\n\n- '))
-        f.seek(0)
-        subprocess.check_call(cmd + ' ' + temp_path, shell=True)
-        yml = f.read()
-        f.truncate()
-        f.close
-
-    os.close(fd)
-    os.remove(temp_path)
-
-    try:
-        data = yaml.load(yml)
-    except:
-        print("Oops, that YAML didn't appear to be valid!", file=sys.stderr)
-        raise SystemExit(1)
-
-    store.dump(data)
-
-
-def is_working():
-    data = store.load()
-    return data.get('work') and 'end' not in data['work'][-1]
-
-
-def ensure_working():
-    if is_working():
-        return
-
-    print("For all I know, you aren't working on anything. "
-          "I don't know what to do.", file=sys.stderr)
-    print('See `ti -h` to know how to start working.', file=sys.stderr)
-    raise SystemExit(1)
-
-
-def to_datetime(timestr):
-    return parse_engtime(timestr).isoformat() + 'Z'
-
-
-def parse_engtime(timestr):
-
-    now = datetime.utcnow()
-    if not timestr or timestr.strip() == 'now':
-        return now
-
-    match = re.match(r'(\d+|a) \s* (s|secs?|seconds?) \s+ ago $',
-                     timestr, re.X)
-    if match is not None:
-        n = match.group(1)
-        seconds = 1 if n == 'a' else int(n)
-        return now - timedelta(seconds=seconds)
-
-    match = re.match(r'(\d+|a) \s* (mins?|minutes?) \s+ ago $', timestr, re.X)
-    if match is not None:
-        n = match.group(1)
-        minutes = 1 if n == 'a' else int(n)
-        return now - timedelta(minutes=minutes)
-
-    match = re.match(r'(\d+|a|an) \s* (hrs?|hours?) \s+ ago $', timestr, re.X)
-    if match is not None:
-        n = match.group(1)
-        hours = 1 if n in ['a', 'an'] else int(n)
-        return now - timedelta(hours=hours)
-
-    raise ValueError("Don't understand the time '" + timestr + "'")
-
-
-def parse_isotime(isotime):
-    return datetime.strptime(isotime, '%Y-%m-%dT%H:%M:%S.%fZ')
-
-
-def timegap(start_time, end_time):
-    diff = end_time - start_time
-
-    mins = diff.seconds / 60
-
-    if mins == 0:
-        return 'less than a minute'
-    elif mins == 1:
-        return 'a minute'
-    elif mins < 44:
-        return '{} minutes'.format(mins)
-    elif mins < 89:
-        return 'about an hour'
-    elif mins < 1439:
-        return 'about {} hours'.format(mins / 60)
-    elif mins < 2519:
-        return 'about a day'
-    elif mins < 43199:
-        return 'about {} days'.format(mins / 1440)
-    elif mins < 86399:
-        return 'about a month'
-    elif mins < 525599:
-        return 'about {} months'.format(mins / 43200)
-    else:
-        return 'more than a year'
-
-
-def helpful_exit(msg=__doc__):
-    print(msg, file=sys.stderr)
-    raise SystemExit
-
-
-def parse_args(argv=sys.argv):
-    global use_color
-
-    argv = [arg.decode('utf-8') for arg in argv]
-
-    if '--no-color' in argv:
-        use_color = False
-        argv.remove('--no-color')
-
-    # prog = argv[0]
-    if len(argv) == 1:
-        helpful_exit('You must specify a command.')
-
-    head = argv[1]
-    tail = argv[2:]
-
-    if head in ['-h', '--help', 'h', 'help']:
-        helpful_exit()
-
-    elif head in ['e', 'edit']:
-        fn = action_edit
-        args = {}
-
-    elif head in ['o', 'on']:
-        if not tail:
-            helpful_exit('Need the name of whatever you are working on.')
-
-        fn = action_on
-        args = {
-            'name': tail[0],
-            'time': to_datetime(' '.join(tail[1:])),
-        }
-
-    elif head in ['f', 'fin']:
-        fn = action_fin
-        args = {'time': to_datetime(' '.join(tail))}
-
-    elif head in ['s', 'status']:
-        fn = action_status
-        args = {}
-
-    elif head in ['l', 'log']:
-        fn = action_log
-        args = {'period': tail[0] if tail else None}
-
-    elif head in ['t', 'tag']:
-        if not tail:
-            helpful_exit('Please provide at least one tag to add.')
-
-        fn = action_tag
-        args = {'tags': tail}
-
-    elif head in ['n', 'note']:
-        if not tail:
-            helpful_exit('Please provide some text to be noted.')
-
-        fn = action_note
-        args = {'content': ' '.join(tail)}
-
-    elif head in ['i', 'interrupt']:
-        if not tail:
-            helpful_exit('Need the name of whatever you are working on.')
-
-        fn = action_interrupt
-        args = {
-            'name': tail[0],
-            'time': to_datetime(' '.join(tail[1:])),
-        }
-
-    else:
-        helpful_exit("I don't understand '" + head + "'")
-
-    return fn, args
-
-
-def main():
-    fn, args = parse_args()
-    fn(**args)
-
-
-store = JsonStore(os.getenv('SHEET_FILE', None) or
-                  os.path.expanduser('~/.ti-sheet'))
-use_color = True
-
-if __name__ == '__main__':
-    main()
+store = JsonStore(os.getenv('SHEET_FILE', None) or os.path.expanduser('~/.ti-sheet'))
diff --git a/ti/actions.py b/ti/actions.py
new file mode 100644
index 0000000..548e289
--- /dev/null
+++ b/ti/actions.py
@@ -0,0 +1,406 @@
+# coding: utf-8
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import pendulum
+import yaml
+import os
+import subprocess
+import sys
+import tempfile
+from pytimeparse.timeparse import timeparse
+from datetime import timedelta
+from collections import defaultdict
+from tabulate import tabulate
+from .store import Store
+from .git import Git
+from .colors import red, yellow, green
+from .utils import seconds_to_hours_and_minutes
+
+
+class Actions(object):
+    store = None
+    equal_to_last = {}
+    subtotals_count = 0
+    subtotals_sum = 0
+    subtotals_key = None
+
+    def __init__(self):
+        self.store = Store()
+
+    def action_on(self, task=None, project=None, ago=None):
+        git = Git()
+        git_support = git.is_git_installed() & git.is_cwd_repo()
+        # print('Is git installed: {}'.format(git.is_git_installed()))
+        # print('Is cwd git repo: {}'.format(git.is_cwd_repo()))
+        # print('Get top level: {}'.format(git.get_top_level()))
+        # print('Get current branch: {}'.format(git.get_active_branch()))
+
+        # project not set
+        if project is None:
+            if git_support:
+                project_path = git.get_top_level()[1:]
+                project = str(project_path).replace('/', '-')
+
+        if task is None:
+            if git_support:
+                task = git.get_active_branch()
+            else:
+                task = os.path.basename(os.getcwd())
+
+        now = pendulum.now()
+        time_text = 'right now'
+        verb_text = 'Starting'
+        if ago:
+            seconds_ago = timeparse(ago)
+            now = now.subtract(seconds=seconds_ago)
+            time_text = now.diff_for_humans()
+            verb_text = 'Started'
+
+        current = self.store.get_current()
+        if current:
+            print('You are already working on task {}. Stop it or use a different sheet.'.format(green(current['task'])),
+                  file=sys.stderr)
+            raise SystemExit(1)
+
+        self.store.add_tracking(task, project, now)
+
+        print('{} working on task {}{} {}.'.format(
+            verb_text,
+            green(task),
+            ' of project {}'.format(red(project)) if project else '',
+            yellow(time_text)
+        ))
+
+    # def action_fin(time, back_from_interrupt=True):
+    def action_fin(self, ago):
+        current = self.ensure_working()
+
+        now = pendulum.now()
+        if ago:
+            seconds_ago = timeparse(ago)
+            now = now.subtract(seconds=seconds_ago)
+
+        self.store.finish_tracking(current, now)
+        print('You were working on {}{} for {} and task is stopped now.'.format(
+            green(current['task']),
+            ' of project {}'.format(red(current['project'])) if current['project'] else '',
+            now.diff_for_humans(current['start'], absolute=True)
+        ))
+
+        # if back_from_interrupt and len(data['interrupt_stack']) > 0:
+        #     name = data['interrupt_stack'].pop()['name']
+        #     store.dump(data)
+        #     action_on(name, time)
+        #     if len(data['interrupt_stack']) > 0:
+        #         print('You are now %d deep in interrupts.'
+        #               % len(data['interrupt_stack']))
+        #     else:
+        #         print('Congrats, you\'re out of interrupts!')
+
+    def action_status(self, short):
+        try:
+            current = self.ensure_working(silent=short)
+
+            diff = pendulum.now().diff_for_humans(current['start'], absolute=True)
+            if short:
+                print('on {}/{} for {}.'.format(
+                    red(current['project']),
+                    green(current['task']),
+                    diff))
+            else:
+                print('You have been working on {0} for {1}.'.format(
+                    green(current['task']), diff))
+
+        except SystemExit:
+            if short:
+                print('idle')
+
+    def action_log(self, period):
+        now = pendulum.now()
+
+        data = []
+        headers = []
+        if period == 'today':
+            today = now.to_date_string()
+            results = self.store.get_logs(today, today)
+
+            for log in results:
+                start = pendulum.parse(log['start'])
+                end = pendulum.parse(log['end'])
+
+                data.append(
+                    (
+                        log['task'],
+                        log['project'],
+                        start.format('%H:%M'),
+                        end.format('%H:%M'),
+                        end.diff_for_humans(start, absolute=True),
+                        '← yes' if log['is_current'] else ''
+                    )
+                )
+                headers = [
+                    'task',
+                    'project',
+                    'start',
+                    'end',
+                    'duration',
+                    'current',
+                ]
+        elif period == 'week':
+            results = self.store.get_logs(now.start_of('week').to_date_string(),
+                                          now.end_of('week').to_date_string())
+
+            for log in results:
+                start = pendulum.parse(log['start'])
+                end = pendulum.parse(log['end'])
+
+                data.append(
+                    (
+                        log['task'],
+                        log['project'],
+                        self.none_if_equal_to_last('day_of_week', start.format('%A')),
+                        self.none_if_equal_to_last('start_date', start.format('%d%_t %b')),
+                        start.format('%H:%M'),
+                        self.none_if_equal_to_last('end_date', end.format('%d%_t %b')),
+                        end.format('%H:%M'),
+                        end.diff_for_humans(start, absolute=True),
+
+                        '← yes' if log['is_current'] else ''
+                    )
+                )
+                headers = [
+                    'task',
+                    'project',
+                    'day of week',
+                    'start',
+                    '',
+                    'end',
+                    '',
+                    'duration',
+                    'current',
+                ]
+        # period is month
+        else:
+            results = self.store.get_logs(now.start_of('month').to_date_string(),
+                                          now.end_of('month').to_date_string())
+
+            for log in results:
+                start = pendulum.parse(log['start'])
+                end = pendulum.parse(log['end'])
+
+                data.append(
+                    (
+                        log['task'],
+                        log['project'],
+                        self.none_if_equal_to_last('day_of_week', start.format('%A')),
+                        self.none_if_equal_to_last('start_date', start.format('%d%_t %b')),
+                        start.format('%H:%M'),
+                        self.none_if_equal_to_last('end_date', end.format('%d%_t %b')),
+                        end.format('%H:%M'),
+                        end.diff_for_humans(start, absolute=True),
+
+                        '← yes' if log['is_current'] else ''
+                    )
+                )
+                headers = [
+                    'task',
+                    'project',
+                    'day of week',
+                    'start',
+                    '',
+                    'end',
+                    '',
+                    'duration',
+                    'current',
+                ]
+        print('\n' + tabulate(data, headers=headers))
+
+    def action_report(self, period):
+        now = pendulum.now()
+
+        if period == 'today':
+            today = now.to_date_string()
+            results = self.store.get_aggregated_logs(today, today)
+
+        elif period == 'week':
+            results = self.store.get_aggregated_logs(now.start_of('week').to_date_string(),
+                                                     now.end_of('week').to_date_string())
+
+        # period is month
+        else:
+            results = self.store.get_aggregated_logs(now.start_of('month').to_date_string(),
+                                                     now.end_of('month').to_date_string())
+
+        data = []
+        headers = [
+            'project',
+            'task',
+            'task total',
+            'project total',
+            'total'
+        ]
+        total = 0
+        for log in results:
+            total += log['total_seconds']
+            subtotals = self.subtotals(log['project'], log['total_seconds'])
+            if subtotals:
+                data.append(
+                    (
+                        '-',
+                        '-',
+                        '-',
+                        seconds_to_hours_and_minutes(subtotals),
+                        ''
+                    )
+                )
+            data.append(
+                (
+                    self.none_if_equal_to_last('project', log['project']),
+                    log['task'],
+                    seconds_to_hours_and_minutes(log['total_seconds']),
+                    '',
+                    ''
+                )
+            )
+        # project subtotals
+        subtotals = self.subtotals('', 0)
+        if subtotals:
+            data.append(
+                (
+                    '-',
+                    '-',
+                    '-',
+                    seconds_to_hours_and_minutes(subtotals),
+                    ''
+                )
+            )
+        # totals
+        data.append(
+            (
+                '',
+                '',
+                '',
+                '',
+                seconds_to_hours_and_minutes(total)
+            )
+        )
+        print('\n' + tabulate(data, headers=headers, tablefmt='simple'))
+
+    # def action_interrupt(name, time):
+    #     ensure_working()
+    #
+    #     action_fin(time, back_from_interrupt=False)
+    #
+    #     data = store.load()
+    #     if 'interrupt_stack' not in data:
+    #         data['interrupt_stack'] = []
+    #     interrupt_stack = data['interrupt_stack']
+    #
+    #     interrupted = data['work'][-1]
+    #     interrupt_stack.append(interrupted)
+    #     store.dump(data)
+    #
+    #     action_on('interrupt: ' + green(name), time)
+    #     print('You are now %d deep in interrupts.' % len(interrupt_stack))
+    #
+    #
+    # def action_note(content):
+    #     ensure_working()
+    #
+    #     data = store.load()
+    #     current = data['work'][-1]
+    #
+    #     if 'notes' not in current:
+    #         current['notes'] = [content]
+    #     else:
+    #         current['notes'].append(content)
+    #
+    #     store.dump(data)
+    #
+    #     print('Yep, noted to ' + yellow(current['name']) + '.')
+    #
+    #
+    # def action_tag(tags):
+    #     ensure_working()
+    #
+    #     data = store.load()
+    #     current = data['work'][-1]
+    #
+    #     current['tags'] = set(current.get('tags') or [])
+    #     current['tags'].update(tags)
+    #     current['tags'] = list(current['tags'])
+    #
+    #     store.dump(data)
+    #
+    #     tag_count = str(len(tags))
+    #     print('Okay, tagged current work with ' + tag_count + ' tag' +
+    #           ('s' if tag_count > 1 else '') + '.')
+    #
+    #
+    # def action_edit():
+    #     if 'EDITOR' not in os.environ:
+    #         print("Please set the 'EDITOR' environment variable", file=sys.stderr)
+    #         raise SystemExit(1)
+    #
+    #     data = store.load()
+    #     yml = yaml.safe_dump(data, default_flow_style=False, allow_unicode=True)
+    #
+    #     cmd = os.getenv('EDITOR')
+    #     fd, temp_path = tempfile.mkstemp(prefix='ti.')
+    #     with open(temp_path, "r+") as f:
+    #         f.write(yml.replace('\n- ', '\n\n- '))
+    #         f.seek(0)
+    #         subprocess.check_call(cmd + ' ' + temp_path, shell=True)
+    #         yml = f.read()
+    #         f.truncate()
+    #         f.close()
+    #
+    #     os.close(fd)
+    #     os.remove(temp_path)
+    #
+    #     try:
+    #         data = yaml.load(yml)
+    #     except:
+    #         print("Oops, that YAML didn't appear to be valid!", file=sys.stderr)
+    #         raise SystemExit(1)
+    #
+    #     store.dump(data)
+    #
+    # def is_working():
+    #     data = store.load()
+    #     return data.get('work') and 'end' not in data['work'][-1]
+
+    def none_if_equal_to_last(self, key, value):
+        if key in self.equal_to_last and self.equal_to_last[key] == value:
+            return '-'
+
+        else:
+            self.equal_to_last[key] = value
+            return value
+
+    def subtotals(self, key, seconds):
+        sum = False
+        if key != self.subtotals_key:
+            if self.subtotals_count > 1:
+                sum = self.subtotals_sum
+            self.subtotals_sum = seconds
+            self.subtotals_key = key
+            self.subtotals_count = 1
+            return sum
+
+        self.subtotals_sum += seconds
+        self.subtotals_count += 1
+        return sum
+
+    def ensure_working(self, silent=False):
+        current = self.store.get_current()
+        if current:
+            return current
+
+        if not silent:
+            print("For all I know, you aren't working on anything. "
+                  "I don't know what to do.", file=sys.stderr)
+            print('See `ti -h` to know how to start working.', file=sys.stderr)
+
+        raise SystemExit(1)
diff --git a/ti/colors.py b/ti/colors.py
new file mode 100644
index 0000000..2facc75
--- /dev/null
+++ b/ti/colors.py
@@ -0,0 +1,30 @@
+# coding: utf-8
+from colorama import Fore
+
+
+def red(_str, use_color=True):
+    if use_color:
+        return Fore.RED + _str + Fore.RESET
+    else:
+        return _str
+
+
+def green(_str, use_color=True):
+    if use_color:
+        return Fore.GREEN + _str + Fore.RESET
+    else:
+        return _str
+
+
+def yellow(_str, use_color=True):
+    if use_color:
+        return Fore.YELLOW + _str + Fore.RESET
+    else:
+        return _str
+
+
+def blue(_str, use_color=True):
+    if use_color:
+        return Fore.BLUE + _str + Fore.RESET
+    else:
+        return _str
diff --git a/ti/git.py b/ti/git.py
new file mode 100644
index 0000000..671f95d
--- /dev/null
+++ b/ti/git.py
@@ -0,0 +1,32 @@
+# coding: utf-8
+import os.path
+import subprocess
+
+
+class Git(object):
+    path = '/usr/bin/git'
+
+    def is_git_installed(self):
+        return os.path.exists(self.path)
+
+    def is_cwd_repo(self):
+        return self.get_cmd_retcode(['git', 'rev-parse', 'HEAD']) == 0
+
+    def get_active_branch(self):
+        return self.get_cmd_retcode_and_output(['git', 'rev-parse', '--abbrev-ref', 'HEAD'])
+
+    def get_top_level(self):
+        return self.get_cmd_retcode_and_output(['git', 'rev-parse', '--show-toplevel'])
+
+    def get_cmd_retcode(self, cmd):
+        devnull = open(os.devnull, 'w')
+        retcode = subprocess.call(cmd, stdout=devnull, stderr=subprocess.STDOUT)
+        return retcode
+
+    def get_cmd_retcode_and_output(self, cmd):
+        process = subprocess.Popen(cmd, stdout=subprocess.PIPE)
+        output = process.communicate()[0]
+        retcode = process.returncode
+        if retcode == 0:
+            return output.decode('utf-8').strip()
+        return False
diff --git a/ti/store.py b/ti/store.py
new file mode 100644
index 0000000..b35af9a
--- /dev/null
+++ b/ti/store.py
@@ -0,0 +1,72 @@
+# coding: utf-8
+import sqlite3
+import os
+
+
+class Store(object):
+    store_file = '~/.ti-sheet.sqlite'
+    conn = None
+    fields = [
+        'id', 'start', 'end', 'start_date', 'in_seconds', 'is_current', 'project', 'task']
+
+    def __init__(self):
+        store_path = os.path.expanduser(self.store_file)
+        self.conn = sqlite3.connect(store_path, detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES)
+        self.conn.row_factory = sqlite3.Row
+
+        with self.conn:
+            res = self.conn.execute('PRAGMA TABLE_INFO(tracking)')
+            names = [tup[1] for tup in res.fetchall()]
+            if not all(x in self.fields for x in names):
+                self.create_schema()
+
+    def create_schema(self):
+        c = self.conn.cursor()
+        ddl = """
+            create table tracking (
+              id integer PRIMARY KEY ,
+              start text,
+              end text,
+              start_date text,
+              in_seconds integer,
+              is_current integer,
+              project text,
+              task text
+            );
+        """
+        try:
+            c.execute(ddl)
+        except sqlite3.OperationalError:
+            pass
+
+    def get_current(self):
+        c = self.conn.cursor()
+        c.execute("select * from tracking where is_current = 1 order by start desc;")
+        row = c.fetchone()
+        if row:
+            return row
+        else:
+            return None
+
+    def add_tracking(self, task, project, start):
+        with self.conn:
+            self.conn.execute("insert into tracking (start, start_date, is_current, project, task)"
+                              " values (?, ?, ?, ?, ?)", (str(start), str(start.to_date_string()), True, project, task))
+
+    def finish_tracking(self, current, end):
+        with self.conn:
+            self.conn.execute("update tracking set is_current = ?, end = ?, in_seconds = ? where id = ?",
+                              (False, str(end), (end-current['start']).total_seconds(), current['id']))
+
+    def get_logs(self, gte, lte):
+        with self.conn:
+            c = self.conn.execute("select * from tracking where start_date >= ? and start_date <= ? order by start",
+                                  (str(gte), str(lte)))
+            return c.fetchall()
+
+    def get_aggregated_logs(self, gte, lte):
+        with self.conn:
+            c = self.conn.execute("select project, task, sum(in_seconds) as total_seconds from tracking "
+                                  "where start_date >= ? and start_date <= ? group by project, task",
+                                  (str(gte), str(lte)))
+            return c.fetchall()
diff --git a/ti/ti.py b/ti/ti.py
new file mode 100644
index 0000000..ac8d87a
--- /dev/null
+++ b/ti/ti.py
@@ -0,0 +1,178 @@
+# coding: utf-8
+"""
+ti is a simple and extensible time tracker for the command line. Visit the
+project page (http://ti.sharats.me) for more details.
+"""
+
+from __future__ import print_function
+from __future__ import unicode_literals
+import argparse
+import sys
+from .actions import Actions
+import sys
+
+
+# def parse_args(argv=sys.argv):
+#     use_color = False
+#
+#     argv = [arg for arg in argv]
+#
+#     if '--no-color' in argv:
+#         use_color = False
+#         argv.remove('--no-color')
+#
+#     # prog = argv[0]
+#     if len(argv) == 1:
+#         helpful_exit('You must specify a command.')
+#
+#     head = argv[1]
+#     tail = argv[2:]
+#
+#     elif head in ['e', 'edit']:
+#         fn = action_edit
+#         args = {}
+#
+#     elif head in ['t', 'tag']:
+#         if not tail:
+#             helpful_exit('Please provide at least one tag to add.')
+#
+#         fn = action_tag
+#         args = {'tags': tail}
+#
+#     elif head in ['n', 'note']:
+#         if not tail:
+#             helpful_exit('Please provide some text to be noted.')
+#
+#         fn = action_note
+#         args = {'content': ' '.join(tail)}
+#
+#     elif head in ['i', 'interrupt']:
+#         if not tail:
+#             helpful_exit('Need the name of whatever you are working on.')
+#
+#         fn = action_interrupt
+#         args = {
+#             'name': tail[0],
+#             'time': to_datetime(' '.join(tail[1:])),
+#         }
+#
+#     else:
+#         helpful_exit("I don't understand '" + head + "'")
+#
+#     return fn, args
+
+
+# Inpired by Multi-level argparse by @chase_seibert
+# http://chase-seibert.github.io/blog/2014/03/21/python-multilevel-argparse.html
+class Ti(object):
+    valid_commands = {
+        'on': ['o', 'on'],
+        'fin': ['f', 'fin'],
+        'status': ['s', 'status'],
+        'log': ['l', 'log'],
+        'report': ['r', 'report'],
+    }
+    actions = None
+
+    def __init__(self):
+        self.actions = Actions()
+        parser = argparse.ArgumentParser(
+            usage=""" ti <command> [<args>]
+
+ti is a simple and extensible time tracker for the command line.
+Visit the project page (http://ti.sharats.me) for more details.
+
+Commands:
+  o, on        Start new tracking
+  f, fin       Stop currently running tracking
+  s, status    Show current status
+  l, log       List time logs for period with possible values today (default), week or month
+  r, report    Aggregated report for period with possible values today (default), week or month
+
+Old commands:
+  ti (t|tag) <tag>...
+  ti (n|note) <note-text>...
+
+  ti (e|edit)
+  ti (i|interrupt)
+  ti --no-color
+
+""")
+        parser.add_argument('command', help='Subcommand to run')
+        # parse_args defaults to [1:] for args, but you need to
+        # exclude the rest of the args too, or validation will fail
+        args = parser.parse_args(sys.argv[1:2])
+
+        reverse_map = {}
+        for k, v1 in self.valid_commands.items():
+            for v2 in v1:
+                reverse_map[v2] = k
+
+        if args.command not in reverse_map:
+            print('Unrecognized command')
+            parser.print_help()
+            exit(1)
+        getattr(self, reverse_map[args.command])()
+
+    def on(self):
+        parser = argparse.ArgumentParser(
+            prog='ti on',
+            description='Track new task')
+
+        parser.add_argument('task', type=str, nargs="?", help="name of task")
+        parser.add_argument('project', type=str, nargs="?", help="group task and tracking under project, "
+                                                                 "useful for aggregation")
+        parser.add_argument('--ago', type=str, metavar="time",
+                            help="shift start of tracking into past, eg. 10 minutes")
+
+        args = parser.parse_args(sys.argv[2:])
+        self.actions.action_on(**vars(args))
+
+    def fin(self):
+        parser = argparse.ArgumentParser(
+            prog='ti fin',
+            description='Finish running task')
+        parser.add_argument('--ago', type=str, metavar="time",
+                            help="shift finish of tracking into past, e.g. 10 minutes")
+
+        args = parser.parse_args(sys.argv[2:])
+        self.actions.action_fin(**vars(args))
+
+    def status(self):
+        parser = argparse.ArgumentParser(
+            prog='ti status',
+            description='Get current status')
+        parser.add_argument('--short', default=False, action="store_true",
+                            help="short status ideal for integration to other tools e.g. bash prompt")
+
+        args = parser.parse_args(sys.argv[2:])
+        self.actions.action_status(**vars(args))
+
+    def log(self):
+        parser = argparse.ArgumentParser(
+            prog='ti log',
+            description='List of time logs for selected period')
+        parser.add_argument('period', type=str, metavar="time", nargs="?", default='today',
+                            choices=['today', 'week', 'month'],
+                            help="period of time, possible choices: today (default), week or month")
+
+        args = parser.parse_args(sys.argv[2:])
+        self.actions.action_log(**vars(args))
+
+    def report(self):
+        parser = argparse.ArgumentParser(
+            prog='ti report',
+            description='Aggregated report of time logs for selected period')
+        parser.add_argument('period', type=str, metavar="time", nargs="?", default='today',
+                            choices=['today', 'week', 'month'],
+                            help="period of time, possible choices: today (default), week or month")
+
+        args = parser.parse_args(sys.argv[2:])
+        self.actions.action_report(**vars(args))
+
+
+def main():
+    Ti()
+
+if __name__ == '__main__':
+    main()
diff --git a/ti/utils.py b/ti/utils.py
new file mode 100644
index 0000000..f203612
--- /dev/null
+++ b/ti/utils.py
@@ -0,0 +1,86 @@
+# coding: utf-8
+from __future__ import print_function
+from __future__ import unicode_literals
+
+# import re
+# from datetime import datetime, timedelta
+import pendulum
+import math
+
+
+# def to_datetime(timestr):
+#     return parse_engtime(timestr).isoformat() + 'Z'
+#
+#
+# def parse_engtime(timestr):
+#
+#     now = datetime.utcnow()
+#     if not timestr or timestr.strip() == 'now':
+#         return now
+#
+#     match = re.match(r'(\d+|a) \s* (s|secs?|seconds?) \s+ ago $',
+#                      timestr, re.X)
+#     if match is not None:
+#         n = match.group(1)
+#         seconds = 1 if n == 'a' else int(n)
+#         return now - timedelta(seconds=seconds)
+#
+#     match = re.match(r'(\d+|a) \s* (mins?|minutes?) \s+ ago $', timestr, re.X)
+#     if match is not None:
+#         n = match.group(1)
+#         minutes = 1 if n == 'a' else int(n)
+#         return now - timedelta(minutes=minutes)
+#
+#     match = re.match(r'(\d+|a|an) \s* (hrs?|hours?) \s+ ago $', timestr, re.X)
+#     if match is not None:
+#         n = match.group(1)
+#         hours = 1 if n in ['a', 'an'] else int(n)
+#         return now - timedelta(hours=hours)
+#
+#     raise ValueError("Don't understand the time '" + timestr + "'")
+#
+#
+# def parse_isotime(isotime):
+#     return datetime.strptime(isotime, '%Y-%m-%dT%H:%M:%S.%fZ')
+#
+#
+# def timegap(start_time, end_time):
+#     diff = end_time - start_time
+#
+#     mins = diff.seconds / 60
+#
+#     if mins == 0:
+#         return 'less than a minute'
+#     elif mins == 1:
+#         return 'a minute'
+#     elif mins < 44:
+#         return '{} minutes'.format(mins)
+#     elif mins < 89:
+#         return 'about an hour'
+#     elif mins < 1439:
+#         return 'about {} hours'.format(mins / 60)
+#     elif mins < 2519:
+#         return 'about a day'
+#     elif mins < 43199:
+#         return 'about {} days'.format(mins / 1440)
+#     elif mins < 86399:
+#         return 'about a month'
+#     elif mins < 525599:
+#         return 'about {} months'.format(mins / 43200)
+#     else:
+#         return 'more than a year'
+
+
+def seconds_to_hours_and_minutes(seconds):
+    ceil_seconds = math.ceil(seconds/60)*60
+    interval = pendulum.interval(seconds=ceil_seconds)
+
+    if interval.total_hours() > 24:
+        hours = math.floor(interval.total_hours())
+        minutes = interval.minutes
+        if minutes > 1:
+            return '{} hours {} minutes'.format(hours, minutes)
+        else:
+            return '{} hours {} minute'.format(hours, minutes)
+
+    return interval.__str__()