Imported Upstream version 0.07.00upstream/0.07.00

26 files changed, 2072 insertions, 31 deletions

diff --git a/lib/CIL.pm b/lib/CIL.pm
index 9a87bf9..548ada3 100644
--- a/lib/CIL.pm
+++ b/lib/CIL.pm
@@ -23,28 +23,51 @@ package CIL;
 
 use strict;
 use warnings;
+use Carp qw(croak confess);
 use File::Glob qw(:glob);
+use File::HomeDir;
+use CIL::Git;
+
+use vars qw( $VERSION );
+$VERSION = '0.07.00';
+
+use Module::Pluggable
+        sub_name    => 'commands',
+        search_path => [ 'CIL::Command' ],
+        require     => 1;
 
 use base qw(Class::Accessor);
 __PACKAGE__->mk_accessors(qw(
     IssueDir
     StatusStrict StatusAllowed StatusOpen StatusClosed
     LabelStrict LabelAllowed
-    VCS
+    DefaultNewStatus
+    UseGit
     UserName UserEmail
+    AutoAssignSelf
+    git hook
 ));
 
 my $defaults = {
-    IssueDir     => 'issues', # the dir to save the issues in
-    StatusStrict => 0,        # whether to complain if a status is invalid
-    LabelStrict  => 0,        # whether to complain if a label is invalid
+    IssueDir         => 'issues', # the dir to save the issues in
+    StatusStrict     => 0,        # whether to complain if a status is invalid
+    LabelStrict      => 0,        # whether to complain if a label is invalid
+    DefaultNewStatus => 'New',    # What Status to use for new issues by default
+    UseGit           => 0,        # don't do anything with Git
 };
 
-my @config_hashes = qw(StatusAllowed StatusOpen StatusClosed LabelAllowed);
+my @config_hashes = qw(StatusOpen StatusClosed LabelAllowed);
 
 my $defaults_user = {
-    UserName  => 'Name',
-    UserEmail => 'me@example.com',
+    UserName       => eval { Git->repository->config( 'user.name' ) } || 'UserName',
+    UserEmail      => eval { Git->repository->config( 'user.email' ) } || 'username@example.org',
+    AutoAssignSelf => 0,
+};
+
+my $allowed = {
+    hook => {
+        'issue_post_save' => 1,
+    },
 };
 
 ## ----------------------------------------------------------------------------
@@ -60,11 +83,15 @@ sub new {
     # save the settings for various bits of info
     foreach my $key ( keys %$defaults ) {
         # if we have been passed it in, use it, else use the default
-        $self->$key( $cfg->{$key} || $defaults->{$key} ); 
+        $self->$key( $cfg->{$key} || $defaults->{$key} );
     }
     return $self;
 }
 
+sub command_names {
+    return map { $_->name } $_[0]->commands;
+}
+
 sub list_entities {
     my ($self, $prefix, $base) = @_;
 
@@ -189,15 +216,23 @@ sub get_attachments_for {
 sub read_config_user {
     my ($self) = @_;
 
-    my $filename = "$ENV{HOME}/.cilrc";
+    my $filename = File::HomeDir->my_home() . '/.cilrc';
 
+    # firstly, set the default config
     my $cfg;
+    %$cfg = %$defaults_user;
+
+    # then read the ~/.cilrc file
     if ( -f $filename ) {
         $cfg = CIL::Utils->parse_cil_file( $filename );
     }
 
-    # set each config to be either the user defined one or the default
-    foreach ( qw(UserName UserEmail) ) {
+    # for some settings, see if we can get it from Git
+    $cfg->{UserName} = eval { Git->repository->config( 'user.name' ) }  || $cfg->{UserName};
+    $cfg->{UserEmail} = eval { Git->repository->config( 'user.email' ) } || $cfg->{UserEmail};
+
+    # save them all internally
+    foreach ( qw(UserName UserEmail AutoAssignSelf) ) {
         $self->$_( $cfg->{$_} || $defaults_user->{$_} );
     }
 }
@@ -212,14 +247,13 @@ sub read_config_file {
     my $cfg;
     if ( -f $filename ) {
         $cfg = CIL::Utils->parse_cil_file( $filename );
+        %$cfg = (%$defaults, %$cfg);
     }
     else {
+        # set some defaults if we don't have a .cil file
         $cfg = $defaults;
     }
 
-    # set some defaults if we don't have any of these
-    %$cfg = (%$defaults, %$cfg);
-
     # for some things, make a hash out of them
     foreach my $hash_name ( @config_hashes ) {
         # if we have nothing in the cfg hash already, set it to empty and move on
@@ -242,16 +276,72 @@ sub read_config_file {
 
     # set each config item
     $self->IssueDir( $cfg->{IssueDir} );
+    $self->UseGit( $cfg->{UseGit} );
 
+    # Status info
     $self->StatusStrict( $cfg->{StatusStrict} );
-    $self->StatusAllowed( $cfg->{StatusAllowed} );
     $self->StatusOpen( $cfg->{StatusOpen} );
     $self->StatusClosed( $cfg->{StatusClosed} );
 
+    # make the StatusAllowed list the sum of StatusOpen and StatusClosed
+    $self->StatusAllowed( { %{$cfg->{StatusOpen}}, %{$cfg->{StatusClosed}} } );
+
+    # Label Info
     $self->LabelStrict( $cfg->{LabelStrict} );
     $self->LabelAllowed( $cfg->{LabelAllowed} );
 
-    $self->VCS( $cfg->{VCS} );
+    $self->DefaultNewStatus( $cfg->{DefaultNewStatus} );
+
+    # create the git instance if we want it
+    $self->UseGit( $cfg->{UseGit} || 0 );
+    if ( $self->UseGit ) {
+        $self->git( CIL::Git->new() );
+    }
+}
+
+sub register_hook {
+    my ($self, $hook_name, $code) = @_;
+
+    unless ( defined $allowed->{hook}{$hook_name} ) {
+        croak "hook '$hook_name' not allowed";
+    }
+
+    push @{$self->{hook}{$hook_name}}, $code;
+}
+
+sub run_hook {
+    my ($self, $hook_name, @rest) = @_;
+
+    unless ( defined $allowed->{hook}{$hook_name} ) {
+        croak "hook '$hook_name' not allowed";
+    }
+
+    # call all the hooks with all the args
+    if ( ref $self->hook eq 'HASH' ) {
+        foreach my $code ( @{$self->hook->{$hook_name}} ) {
+            &$code( $self, @rest );
+        }
+    }
+}
+
+sub file_exists {
+    my ($self, $filename) = @_;
+    return -f $filename;
+}
+
+sub dir_exists {
+    my ($self, $dir) = @_;
+    return -d $dir;
+}
+
+sub parse_cil_file {
+    my ($self, $filename, $last_field) = @_;
+    return CIL::Utils->parse_cil_file($filename, $last_field);
+}
+
+sub save {
+    my ($self, $filename, $data, @fields) = @_;
+    return CIL::Utils->write_cil_file( $filename, $data, @fields );
 }
 
 ## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Attachment.pm b/lib/CIL/Attachment.pm
index 337ed1a..ee2a73a 100644
--- a/lib/CIL/Attachment.pm
+++ b/lib/CIL/Attachment.pm
@@ -81,6 +81,10 @@ sub prefix {
     return 'a';
 }
 
+sub type {
+    return 'Attachment';
+}
+
 sub fields {
     return \@FIELDS;
 }
diff --git a/lib/CIL/Base.pm b/lib/CIL/Base.pm
index f9b932f..34fba60 100644
--- a/lib/CIL/Base.pm
+++ b/lib/CIL/Base.pm
@@ -38,11 +38,11 @@ sub new_from_name {
     croak 'provide a name'
         unless defined $name;
 
-    my $filename = $class->create_filename($cil, $name);
+    my $filename = $class->filename($cil, $name);
     croak "filename '$filename' does no exist"
-        unless -f $filename;
+        unless $cil->file_exists($filename);
 
-    my $data = CIL::Utils->parse_cil_file($filename, $class->last_field);
+    my $data = $cil->parse_cil_file($filename, $class->last_field);
     my $issue = $class->new_from_data( $name, $data );
     return $issue;
 }
@@ -74,6 +74,7 @@ sub new_from_data {
         $self->set_no_update($field, $data->{$field});
     }
     $self->set_no_update('Changed', 0);
+    $self->set_no_update('Updated', $data->{Updated});
 
     return $self;
 }
@@ -115,10 +116,11 @@ sub set_data {
 sub save {
     my ($self, $cil) = @_;
 
-    my $filename = $self->create_filename($cil, $self->name);
+    my $filename = $self->filename($cil, $self->name);
 
     my $fields = $self->fields();
-    CIL::Utils->write_cil_file( $filename, $self->{data}, @$fields );
+
+    $cil->save( $filename, $self->{data}, @$fields );
 }
 
 sub as_output {
@@ -127,7 +129,7 @@ sub as_output {
     return CIL::Utils->format_data_as_output( $self->{data}, @$fields );
 }
 
-sub create_filename {
+sub filename {
     my ($class, $cil, $name) = @_;
 
     # create the filename from it's parts
@@ -170,10 +172,7 @@ sub set {
 # so that we can update fields without 'Updated' being changed
 sub set_no_update {
     my ($self, $field, $value) = @_;
-
-    my $saved_update_time = $self->Updated;
-    $self->set( $field, $value );
-    $self->Updated( $saved_update_time );
+    $self->{data}{$field} = $value;
 }
 
 sub set_inserted_now {
diff --git a/lib/CIL/Command.pm b/lib/CIL/Command.pm
new file mode 100644
index 0000000..194047b
--- /dev/null
+++ b/lib/CIL/Command.pm
@@ -0,0 +1,17 @@
+package CIL::Command;
+
+use strict;
+use warnings;
+
+sub name {
+    my $self = shift;
+
+    my $name = lc( ref $self || $self );
+
+    $name =~ s/^CIL::Command:://i;
+
+    return $name;
+}
+
+
+'end of package CIL::Command';
diff --git a/lib/CIL/Command/Add.pm b/lib/CIL/Command/Add.pm
new file mode 100644
index 0000000..76b1785
--- /dev/null
+++ b/lib/CIL/Command/Add.pm
@@ -0,0 +1,65 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Add;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'add' }
+
+sub run {
+    my ($self, $cil, $args, @argv) = @_;
+
+    CIL::Utils->ensure_interactive();
+
+    my $user = CIL::Utils->user($cil);
+
+    my $issue = CIL::Issue->new('tmpname');
+    $issue->Summary( join ' ', @argv );
+    $issue->Status($cil->DefaultNewStatus);
+    $issue->CreatedBy( $user );
+    $issue->AssignedTo( $user )
+        if ( $args->{mine} or $cil->AutoAssignSelf );
+    $issue->Description("Description ...");
+
+    $issue = CIL::Utils->add_issue_loop($cil, undef, $issue);
+
+    if ( $cil->UseGit ) {
+        # if we want to add or commit this issue
+        if ( $args->{add} or $args->{commit} ) {
+            $cil->git->add( $cil, $issue );
+        }
+
+        # if we want to commit this issue
+        if ( $args->{commit} ) {
+            $cil->git->commit( $cil, 'New Issue', $issue );
+        }
+    }
+}
+
+1;
+
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Am.pm b/lib/CIL/Command/Am.pm
new file mode 100644
index 0000000..5b763ea
--- /dev/null
+++ b/lib/CIL/Command/Am.pm
@@ -0,0 +1,140 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Am;
+
+use strict;
+use warnings;
+
+use File::Slurp qw(read_file write_file);
+use Email::Date qw(find_date);
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'am' }
+
+sub run {
+    my ($self, $cil, $args, $email_filename) = @_;
+
+    unless ( -r $email_filename ) {
+        CIL::Utils::fatal("couldn't load email '$email_filename'");
+    }
+
+    my $msg_text = read_file($email_filename);
+
+    my $email = Email::Simple->new($msg_text);
+    unless ( defined $email ) {
+        CIL::Utils::fatal("email file '$email_filename' didn't look like an email");
+    }
+
+    # extract some fields
+    my $subject = $email->header('Subject');
+    my $from    = $email->header('From');
+    my $date    = find_date($email)->datetime;
+    my $body    = $email->body;
+
+    # see if we can find any issue names in either the subject or the body
+    my @issue_names;
+    foreach my $text ( $subject, $body ) {
+        my @new = ( $text =~ /\b\#?([0-9a-f]{8})\b/gxms );
+        push @issue_names, @new;
+    }
+
+    CIL::Utils->msg("Found possible issue names in email: ", ( join(' ', @issue_names) || '[none]' ));
+
+    my %issue;
+    foreach ( @issue_names ) {
+        my $i = eval { CIL::Issue->new_from_name($cil, $_) };
+        next unless defined $i;
+
+        $issue{$i->name} = $i;
+    }
+
+    if ( keys %issue ) {
+        CIL::Utils->msg( "Found actual issues: " . (join(' ', keys %issue)) );
+
+        # create the new comment
+        my $comment = CIL::Comment->new('tmpname');
+        $comment->Issue( '...' );
+        $comment->CreatedBy( $from );
+        $comment->Inserted( $date );
+        # $comment->Updated( $date );
+        $comment->Description( $body );
+
+        # display
+        CIL::Utils->display_comment($cil, $comment);
+
+        # found at least one issue, so this might be a comment
+        my $issue;
+        if ( keys %issue == 1 ) {
+            $issue = (values %issue)[0];
+        }
+        else {
+            if ( $args->{batch} ) {
+                CIL::Utils->fatal('Cannot add to an existing message (in batch mode) when there are multiple matched messages!');
+            }
+            my $ans = CIL::Utils::ans('To which issue would you like to add this comment: ');
+
+            # ToDo: decide whether we let them choose an arbitrary issue, for
+            # now quit unless they choose one from the list
+            return unless exists $issue{$ans};
+
+            # got a valid issue_name, so set the parent name
+            $issue = $issue{$ans};
+        }
+
+        # set the parent issue
+        $comment->Issue( $issue->name );
+
+        CIL::Utils->add_comment_loop($cil, undef, $issue, $comment);
+    }
+    else {
+        CIL::Utils->msg("Couldn't find reference to any issues in the email.");
+
+        # no issue found so make up the issue first
+        my $issue = CIL::Issue->new('tmpname');
+        $issue->Summary( $subject );
+        $issue->Status($cil->DefaultNewStatus);
+        $issue->CreatedBy( $from );
+        $issue->AssignedTo( CIL::Utils->user($cil) );
+        $issue->Inserted( $date );
+        $issue->Updated( $date );
+        $issue->Description( $body );
+
+        # display
+        CIL::Utils->display_issue_full($cil, $issue);
+
+        # then ask if the user would like to add it
+        CIL::Utils->msg("Couldn't find any likely issues, so this might be a new one.");
+        if ( $args->{batch} ) {
+            CIL::Utils->msg('Running in batch mode, so just adding mail as a new issue');
+        } else {
+            my $ans = CIL::Utils::ans('Would you like to add this message as an issue shown above (y/n): ');
+            return unless $ans eq 'y';
+        }
+
+        CIL::Utils->add_issue_loop($cil, undef, $issue);
+    }
+}
+
+1;
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Attach.pm b/lib/CIL/Command/Attach.pm
new file mode 100644
index 0000000..f114614
--- /dev/null
+++ b/lib/CIL/Command/Attach.pm
@@ -0,0 +1,88 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Attach;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+use File::Basename;
+use File::Slurp;
+use Digest::MD5 qw(md5_hex);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'attach' }
+
+sub run {
+    my ($self, $cil, undef, $issue_name, $filename) = @_;
+
+    my $issue = CIL::Utils->load_issue_fuzzy( $cil, $issue_name );
+
+    # check to see if the file exists
+    unless ( -r $filename ) {
+        $cil->fatal("couldn't read file '$filename'");
+    }
+
+    my $basename = basename( $filename );
+    my $user = CIL::Utils->user($cil);
+
+    my $add_attachment_text = <<"EOF";
+Filename    : $basename
+CreatedBy   : $user
+
+File goes here ... this will be overwritten.
+EOF
+
+    # read in the new issue text
+    CIL::Utils->ensure_interactive();
+    my $fh = CIL::Utils->solicit( $add_attachment_text );
+
+    my $attachment = CIL::Attachment->new_from_fh( 'tmp', $fh );
+    unless ( defined $attachment ) {
+        $cil->fatal("could not create new attachment");
+    }
+
+    # now add the file itself
+    my $contents = read_file( $filename );
+    $attachment->set_file_contents( $contents );
+
+    # set the size
+    my ($size) = (stat($filename))[7];
+    $attachment->Size( $size );
+
+    # we've got the attachment, so let's name it
+    my $unique_str = time . $attachment->Inserted . $attachment->File;
+    $attachment->set_name( substr(md5_hex($unique_str), 0, 8) );
+
+    # finally, tell it who it's parent is and then save
+    $attachment->Issue( $issue->name );
+    $attachment->save($cil);
+
+    # add the comment to the issue, update it's timestamp and save it out
+    $issue->add_attachment( $attachment );
+    $issue->save($cil);
+    CIL::Utils->display_issue_full($cil, $issue);
+}
+
+1;
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Comment.pm b/lib/CIL/Command/Comment.pm
new file mode 100644
index 0000000..0942982
--- /dev/null
+++ b/lib/CIL/Command/Comment.pm
@@ -0,0 +1,63 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Comment;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'comment' }
+
+sub run {
+    my ($self, $cil, $args, $issue_name) = @_;
+
+    my $issue = CIL::Utils->load_issue_fuzzy( $cil, $issue_name );
+
+    CIL::Utils->ensure_interactive();
+
+    # create the new comment
+    my $comment = CIL::Comment->new('tmpname');
+    $comment->Issue( $issue->name );
+    $comment->CreatedBy( CIL::Utils->user($cil) );
+    $comment->Description("Description ...");
+
+    $comment = CIL::Utils->add_comment_loop($cil, undef, $issue, $comment);
+
+    if ( $cil->UseGit ) {
+        # if we want to add or commit this comment
+        if ( $args->{add} or $args->{commit} ) {
+            $cil->git->add( $cil, $issue );
+            $cil->git->add( $cil, $comment );
+        }
+
+        # if we want to commit this comment
+        if ( $args->{commit} ) {
+            $cil->git->commit( $cil, 'New Comment', $issue, $comment );
+        }
+    }
+}
+
+1;
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/DependsOn.pm b/lib/CIL/Command/DependsOn.pm
new file mode 100644
index 0000000..1df5f19
--- /dev/null
+++ b/lib/CIL/Command/DependsOn.pm
@@ -0,0 +1,61 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::DependsOn;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'depends-on' }
+
+sub run {
+    my ($self, $cil, $args, $issue_name, $depends_name) = @_;
+
+    my $issue = CIL::Utils->load_issue_fuzzy($cil, $issue_name);
+    my $depends = CIL::Utils->load_issue_fuzzy($cil, $depends_name);
+
+    $issue->add_depends_on( $depends->name );
+    $depends->add_precedes( $issue->name );
+
+    $issue->save($cil);
+    $depends->save($cil);
+
+    if ( $cil->UseGit ) {
+        # if we want to add or commit this change
+        if ( $args->{add} or $args->{commit} ) {
+            $cil->git->add( $cil, $issue );
+            $cil->git->add( $cil, $depends );
+        }
+
+        # if we want to commit this change
+        if ( $args->{commit} ) {
+            my $message = 'Issue ' . $issue->name . ' has a new dependent ' . $depends->name;
+            $cil->git->commit_multiple( $cil, $message, $issue, $depends );
+        }
+    }
+}
+
+1;
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Edit.pm b/lib/CIL/Command/Edit.pm
new file mode 100644
index 0000000..2f7a7e0
--- /dev/null
+++ b/lib/CIL/Command/Edit.pm
@@ -0,0 +1,84 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Edit;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+my $y = 'y';
+
+## ----------------------------------------------------------------------------
+
+sub name { 'edit' }
+
+sub run {
+    my ($self, $cil, $args, $issue_name) = @_;
+
+    my $issue = CIL::Utils->load_issue_fuzzy( $cil, $issue_name );
+
+    CIL::Utils->ensure_interactive();
+
+    my $edit = $y;
+
+    # keep going until we get a valid issue or we want to quit
+    while ( $edit eq $y ) {
+        # read in the new issue text
+        my $fh = CIL::Utils->solicit( $issue->as_output );
+        $issue = CIL::Issue->new_from_fh( $issue->name, $fh );
+
+        # check if the issue is valid
+        if ( $issue->is_valid($cil) ) {
+            $edit = 'n';
+        }
+        else {
+            CIL::Utils->msg($_) foreach @{ $issue->errors };
+            $edit = CIL::Utils::ans('Would you like to re-edit (y/n): ');
+        }
+    }
+
+    # if the issue is still invalid, they quit without correcting it
+    return unless $issue->is_valid( $cil );
+
+    # save it
+    $issue->save($cil);
+
+    if ( $cil->UseGit ) {
+        # if we want to add or commit this issue
+        if ( $args->{add} or $args->{commit} ) {
+            $cil->git->add( $cil, $issue );
+        }
+
+        # if we want to commit this issue
+        if ( $args->{commit} ) {
+            $cil->git->commit( $cil, 'Issue Edited', $issue );
+        }
+    }
+
+    CIL::Utils->display_issue($cil, $issue);
+}
+
+1;
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Extract.pm b/lib/CIL/Command/Extract.pm
new file mode 100644
index 0000000..03df451
--- /dev/null
+++ b/lib/CIL/Command/Extract.pm
@@ -0,0 +1,45 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Extract;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+use File::Slurp qw(write_file);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'extract' }
+
+sub run {
+    my ($self, $cil, $args, $attachment_name) = @_;
+
+    my $attachment = CIL::Utils->load_attachment_fuzzy($cil, $attachment_name);
+
+    my $filename = $args->{f} || $attachment->Filename();
+    write_file( $filename, $attachment->as_binary );
+}
+
+1;
+
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Fsck.pm b/lib/CIL/Command/Fsck.pm
new file mode 100644
index 0000000..2c48b36
--- /dev/null
+++ b/lib/CIL/Command/Fsck.pm
@@ -0,0 +1,185 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Fsck;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'fsck' }
+
+sub run {
+    my ($self, $cil, $args) = @_;
+
+
+    # this looks at all the issues it can find and checks for:
+    # * validity
+    # * all the comments are there
+    # * all the attachments are there
+    # then it checks each individual comment/attachment for:
+    # * ToDo: validity
+    # * it's parent exists
+
+    # find all the issues, comments and attachments
+    my $issues = $cil->get_issues();
+    my $issue = {};
+    foreach my $i ( @$issues ) {
+        $issue->{$i->name} = $i;
+    }
+    my $comments = $cil->get_comments();
+    my $comment = {};
+    foreach my $c ( @$comments ) {
+        $comment->{$c->name} = $c;
+    }
+    my $attachments = $cil->get_attachments();
+    my $attachment = {};
+    foreach my $a ( @$attachments ) {
+        $attachment->{$a->name} = $a;
+    }
+
+    # ------
+    # issues
+    my $errors = {};
+    if ( @$issues ) {
+        foreach my $i ( sort { $a->Inserted cmp $b->Inserted } @$issues ) {
+            my $name = $i->name;
+
+            unless ( $i->is_valid($cil) ) {
+                foreach ( @{ $i->errors } ) {
+                    push @{$errors->{$name}}, $_;
+                }
+            }
+
+            # check that all it's comments are there and that they have this parent
+            my $comments = $i->CommentList;
+            foreach my $c ( @$comments ) {
+                # see if this comment exists at all
+                if ( exists $comment->{$c} ) {
+                    # check the parent is this issue
+                    push @{$errors->{$name}}, "comment '$c' is listed under issue '" . $i->name . "' but does not reciprocate"
+                        unless $comment->{$c}->Issue eq $i->name;
+                }
+                else {
+                    push @{$errors->{$name}}, "comment '$c' listed in issue '" . $i->name . "' does not exist";
+                }
+            }
+
+            # check that all it's attachments are there and that they have this parent
+            my $attachments = $i->AttachmentList;
+            foreach my $a ( @$attachments ) {
+                # see if this attachment exists at all
+                if ( exists $attachment->{$a} ) {
+                    # check the parent is this issue
+                    push @{$errors->{$name}}, "attachment '$a' is listed under issue '" . $i->name . "' but does not reciprocate"
+                        unless $attachment->{$a}->Issue eq $i->name;
+                }
+                else {
+                    push @{$errors->{$name}}, "attachment '$a' listed in issue '" . $i->name . "' does not exist";
+                }
+            }
+
+            # check that all it's 'DependsOn' are there and that they have this under 'Precedes'
+            my $depends_on = $i->DependsOnList;
+            foreach my $d ( @$depends_on ) {
+                # see if this issue exists at all
+                if ( exists $issue->{$d} ) {
+                    # check the 'Precedes' is this issue
+                    my %precedes = map { $_ => 1 } @{$issue->{$d}->PrecedesList};
+                    push @{$errors->{$name}}, "issue '$d' should precede '" . $i->name . "' but doesn't"
+                        unless exists $precedes{$i->name};
+                }
+                else {
+                    push @{$errors->{$name}}, "issue '$d' listed as a dependency of issue '" . $i->name . "' does not exist";
+                }
+            }
+
+            # check that all it's 'Precedes' are there and that they have this under 'DependsOn'
+            my $precedes = $i->PrecedesList;
+            foreach my $p ( @$precedes ) {
+                # see if this issue exists at all
+                if ( exists $issue->{$p} ) {
+                    # check the 'DependsOn' is this issue
+                    my %depends_on = map { $_ => 1 } @{$issue->{$p}->DependsOnList};
+                    push @{$errors->{$name}}, "issue '$p' should depend on '" . $i->name . "' but doesn't"
+                        unless exists $depends_on{$i->name};
+                }
+                else {
+                    push @{$errors->{$name}}, "issue '$p' listed as preceding issue '" . $i->name . "' does not exist";
+                }
+            }
+        }
+    }
+    print_fsck_errors('Issue', $errors);
+
+    # --------
+    # comments
+    $errors = {};
+    # loop through all the comments
+    if ( @$comments ) {
+        # check that their parent issues exist
+        foreach my $c ( sort { $a->Inserted cmp $b->Inserted } @$comments ) {
+            # check that the parent of each comment exists
+            unless ( exists $issue->{$c->Issue} ) {
+                push @{$errors->{$c->name}}, "comment '" . $c->name . "' refers to issue '" . $c->Issue . "' but issue does not exist";
+            }
+        }
+    }
+    print_fsck_errors('Comment', $errors);
+
+    # -----------
+    # attachments
+    $errors = {};
+    # loop through all the attachments
+    if ( @$attachments ) {
+        # check that their parent issues exist
+        foreach my $a ( sort { $a->Inserted cmp $b->Inserted } @$attachments ) {
+            # check that the parent of each attachment exists
+            unless ( exists $issue->{$a->Issue} ) {
+                push @{$errors->{$a->name}}, "attachment '" . $a->name . "' refers to issue '" . $a->Issue . "' but issue does not exist";
+            }
+        }
+    }
+    print_fsck_errors('Attachment', $errors);
+
+    # ------------
+    # nothing left
+    CIL::Utils->separator();
+}
+
+sub print_fsck_errors {
+    my ($entity, $errors) = @_;
+    return unless keys %$errors;
+
+    CIL::Utils->separator();
+    foreach my $issue_name ( keys %$errors ) {
+        CIL::Utils->title( "$entity $issue_name ");
+        foreach my $error ( @{$errors->{$issue_name}} ) {
+            CIL::Utils->msg("* $error");
+        }
+    }
+}
+
+1;
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Init.pm b/lib/CIL/Command/Init.pm
new file mode 100644
index 0000000..1bf92d5
--- /dev/null
+++ b/lib/CIL/Command/Init.pm
@@ -0,0 +1,108 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Init;
+
+use strict;
+use warnings;
+use File::Slurp qw(read_file write_file);
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'init' }
+
+sub run {
+    my ($self, $cil, $args) = @_;
+
+    my $path = $args->{p} || '.'; # default path is right here
+
+    # error if $path doesn't exist
+    unless ( -d $path ) {
+        CIL::Utils->fatal("path '$path' doesn't exist");
+    }
+
+    # error if issues/ already exists
+    my $issues_dir = "$path/issues";
+    if ( -d $issues_dir ) {
+        CIL::Utils->fatal("issues directory '$issues_dir' already exists, not initialising issues");
+    }
+
+    # error if .cil already exists
+    my $config = "$path/.cil";
+    if ( -f $config ) {
+        CIL::Utils->fatal("config file '$config' already exists, not initialising issues");
+    }
+
+    # try to create the issues/ dir
+    unless ( mkdir $issues_dir ) {
+        CIL::Utils->fatal("Couldn't create '$issues_dir' directory: $!");
+    }
+
+    # are we in a Git repository?
+    my $use_git = 0;
+    if ( -d '.git' ) {
+        CIL::Utils->msg( 'git repository detected, setting to use it' );
+        $use_git = 1;
+    }
+
+    # create a .cil file here also
+    if ( $args->{bare} ) {
+        unless ( touch $config ) {
+            rmdir $issues_dir;
+            CIL::Utils->fatal("couldn't create a '$config' file");
+        }
+    }
+    else {
+        # write a default .cil file
+        write_file($config, <<"CONFIG");
+UseGit: $use_git
+StatusStrict: 1
+StatusOpenList: New
+StatusOpenList: InProgress
+StatusClosedList: Finished
+DefaultNewStatus: New
+LabelStrict: 1
+LabelAllowedList: Type-Enhancement
+LabelAllowedList: Type-Defect
+LabelAllowedList: Priority-High
+LabelAllowedList: Priority-Medium
+LabelAllowedList: Priority-Low
+CONFIG
+    }
+
+    # add a README.txt so people know what this is about
+    unless ( -f "$issues_dir/README.txt" ) {
+        write_file("$issues_dir/README.txt", <<'README');
+This directory is used by CIL to track issues and feature requests.
+
+The home page for CIL is at http://www.chilts.org/projects/cil/
+README
+    }
+
+    # $path/issues/ and $path/.cil create correctly
+    CIL::Utils->msg("initialised empty issue list inside '$path/'");
+}
+
+1;
+
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Label.pm b/lib/CIL/Command/Label.pm
new file mode 100644
index 0000000..d8da2c8
--- /dev/null
+++ b/lib/CIL/Command/Label.pm
@@ -0,0 +1,82 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Label;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'label' }
+
+sub run {
+    my ($self, $cil, $args, $label, @issue_names) = @_;
+
+    unless ( defined $label ) {
+        CIL::Utils->fatal("provide a valid label to add to this issue");
+    }
+
+    my @issues;
+
+    # for every issue
+    foreach my $issue_name ( @issue_names ) {
+        # firstly, read the issue in
+        my $issue = CIL::Utils->load_issue_fuzzy( $cil, $issue_name );
+
+        # decide whether we are adding or removing this label
+        if ( $args->{remove} ) {
+            $issue->remove_label( $label );
+        }
+        else {
+            $issue->add_label( $label );
+        }
+
+        # save
+        $issue->save($cil);
+
+        if ( $cil->UseGit ) {
+            # if we want to add or commit this issue
+            if ( $args->{add} or $args->{commit} ) {
+                $cil->git->add( $cil, $issue );
+            }
+        }
+
+        push @issues, $issue;
+    }
+
+    if ( $cil->UseGit ) {
+        # if we want to commit these issues
+        if ( $args->{commit} ) {
+            if ( $args->{remove} ) {
+                $cil->git->commit_multiple( $cil, "Removed label '$label'", @issues );
+            }
+            else {
+                $cil->git->commit_multiple( $cil, "Added label '$label'", @issues );
+            }
+        }
+    }
+}
+
+1;
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/List.pm b/lib/CIL/Command/List.pm
new file mode 100644
index 0000000..cdb5b03
--- /dev/null
+++ b/lib/CIL/Command/List.pm
@@ -0,0 +1,55 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::List;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'list' }
+
+sub run {
+    my ($self, $cil, $args) = @_;
+
+    CIL::Utils->check_paths($cil);
+
+    # find all the issues
+    my $issues = $cil->get_issues();
+    $issues = CIL::Utils->filter_issues( $cil, $issues, $args );
+    if ( @$issues ) {
+        foreach my $issue ( sort { $a->Inserted cmp $b->Inserted } @$issues ) {
+            CIL::Utils->separator();
+            CIL::Utils->display_issue_headers($issue);
+        }
+        CIL::Utils->separator();
+    }
+    else {
+        CIL::Utils->msg('no issues found');
+    }
+}
+
+1;
+
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Precedes.pm b/lib/CIL/Command/Precedes.pm
new file mode 100644
index 0000000..0fdf12e
--- /dev/null
+++ b/lib/CIL/Command/Precedes.pm
@@ -0,0 +1,62 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Precedes;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'precedes' }
+
+sub run {
+    my ($self, $cil, $args, $issue_name, $precedes_name) = @_;
+
+    my $issue = CIL::Utils->load_issue_fuzzy($cil, $issue_name);
+    my $precedes = CIL::Utils->load_issue_fuzzy($cil, $precedes_name);
+
+    $issue->add_precedes( $precedes->name );
+    $precedes->add_depends_on( $issue->name );
+
+    $issue->save($cil);
+    $precedes->save($cil);
+
+    if ( $cil->UseGit ) {
+        # if we want to add or commit this change
+        if ( $args->{add} or $args->{commit} ) {
+            $cil->git->add( $cil, $issue );
+            $cil->git->add( $cil, $precedes );
+        }
+
+        # if we want to commit this change
+        if ( $args->{commit} ) {
+            my $message = 'Issue ' . $issue->name . ' precedes ' . $precedes->name;
+            $cil->git->commit_multiple( $cil, $message, $issue, $precedes );
+        }
+    }
+}
+
+1;
+
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Show.pm b/lib/CIL/Command/Show.pm
new file mode 100644
index 0000000..865fa3a
--- /dev/null
+++ b/lib/CIL/Command/Show.pm
@@ -0,0 +1,42 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Show;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'show' }
+
+sub run {
+    my ($self, $cil, undef, $issue_name) = @_;
+
+    # firstly, read the issue in
+    my $issue = CIL::Utils->load_issue_fuzzy( $cil, $issue_name );
+    CIL::Utils->display_issue_full($cil, $issue);
+}
+
+1;
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Status.pm b/lib/CIL/Command/Status.pm
new file mode 100644
index 0000000..b74f2ae
--- /dev/null
+++ b/lib/CIL/Command/Status.pm
@@ -0,0 +1,71 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Status;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'status' }
+
+sub run {
+    my ($self, $cil, $args, $status, @issue_names) = @_;
+
+    unless ( defined $status ) {
+        CIL::Utils->fatal("provide a valid status to set this issue to");
+    }
+
+    my @issues;
+
+    # for every issue, read it it and set the Status
+    foreach my $issue_name ( @issue_names ) {
+        # firstly, read the issue in
+        my $issue = CIL::Utils->load_issue_fuzzy( $cil, $issue_name );
+
+        # set the label for this issue
+        $issue->Status( $status );
+        $issue->save($cil);
+
+        # if we want to add or commit this issue
+        if ( $cil->UseGit ) {
+            if ( $args->{add} or $args->{commit} ) {
+                $cil->git->add( $cil, $issue );
+            }
+        }
+
+        push @issues, $issue;
+    }
+
+    if ( $cil->UseGit ) {
+        # if we want to commit these issues
+        if ( $args->{commit} ) {
+            my $message = "Status changed to '$status'";
+            $cil->git->commit_multiple( $cil, $message, @issues );
+        }
+    }
+}
+
+1;
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Steal.pm b/lib/CIL/Command/Steal.pm
new file mode 100644
index 0000000..641c5ae
--- /dev/null
+++ b/lib/CIL/Command/Steal.pm
@@ -0,0 +1,59 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Steal;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'steal' }
+
+sub run {
+    my ($self, $cil, $args, $issue_name) = @_;
+
+    # firstly, read the issue in
+    my $issue = CIL::Utils->load_issue_fuzzy( $cil, $issue_name );
+
+    # set the AssignedTo for this issue to you (because you're stealing it)
+    $issue->AssignedTo( CIL::Utils->user($cil) );
+    $issue->save($cil);
+
+    if ( $cil->UseGit ) {
+        # if we want to add or commit this issue
+        if ( $args->{add} or $args->{commit} ) {
+            $cil->git->add( $cil, $issue );
+        }
+
+        # if we want to commit this issue
+        if ( $args->{commit} ) {
+            $cil->git->commit( $cil, 'Issue Stolen', $issue );
+        }
+    }
+
+    CIL::Utils->display_issue_full($cil, $issue);
+}
+
+1;
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Summary.pm b/lib/CIL/Command/Summary.pm
new file mode 100644
index 0000000..f5a3ab6
--- /dev/null
+++ b/lib/CIL/Command/Summary.pm
@@ -0,0 +1,55 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Summary;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'summary' }
+
+sub run {
+    my ($self, $cil, $args) = @_;
+
+    CIL::Utils->check_paths($cil);
+
+    # find all the issues
+    my $issues = $cil->get_issues();
+    $issues = CIL::Utils->filter_issues( $cil, $issues, $args );
+    if ( @$issues ) {
+        CIL::Utils->separator();
+        foreach my $issue ( @$issues ) {
+            CIL::Utils->display_issue_summary($issue);
+        }
+        CIL::Utils->separator();
+    }
+    else {
+        CIL::Utils->msg('no issues found');
+    }
+}
+
+1;
+
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Track.pm b/lib/CIL/Command/Track.pm
new file mode 100644
index 0000000..ce2f879
--- /dev/null
+++ b/lib/CIL/Command/Track.pm
@@ -0,0 +1,51 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Track;
+
+use strict;
+use warnings;
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'track' }
+
+sub run {
+    my ($self, $cil, undef, $issue_name) = @_;
+
+    CIL::Utils->fatal("to use this feature the 'UseGit' option in your .cil file should be set")
+        unless $cil->UseGit;
+
+    my $issue = CIL::Utils->load_issue_fuzzy($cil, $issue_name);
+
+    # add the issue to Git
+    my $issue_dir = $cil->IssueDir();
+    my @files;
+    push @files, "$issue_dir/i_" . $issue->name . '.cil';
+    push @files, map { "$issue_dir/c_${_}.cil" } @{ $issue->CommentList };
+    push @files, map { "$issue_dir/a_${_}.cil" } @{ $issue->AttachmentList };
+    CIL::Utils->msg("git add @files");
+}
+
+1;
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Command/Work.pm b/lib/CIL/Command/Work.pm
new file mode 100644
index 0000000..83f8d7c
--- /dev/null
+++ b/lib/CIL/Command/Work.pm
@@ -0,0 +1,64 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Command::Work;
+
+use strict;
+use warnings;
+use File::Slurp qw(read_file write_file);
+
+use base qw(CIL::Command);
+
+## ----------------------------------------------------------------------------
+
+sub name { 'work' }
+
+sub run {
+    my ($self, $cil, $args, $issue_name) = @_;
+
+    CIL::Utils->fatal("to use this feature the 'UseGit' option in your .cil file should be set")
+        unless $cil->UseGit;
+
+    # firstly, read the issue in
+    my $issue = CIL::Utils->load_issue_fuzzy( $cil, $issue_name );
+
+    # right, got it's name, let's see if there is a branch for it
+    my @branches = $cil->git->branches();
+    my $branch = {};
+    foreach ( @branches ) {
+        $branch->{substr $_, 2} = 1;
+    }
+    if ( exists $branch->{$issue->name} ) {
+        $cil->git->switch_to_branch( $issue->name );
+    }
+    else {
+        $cil->git->create_branch( $issue->name );
+    }
+
+    # now that we've switched branches, load the issue in again (just in case)
+    $issue = CIL::Utils->load_issue_fuzzy( $cil, $issue_name );
+    $issue->Status( 'InProgress' );
+    $issue->save($cil);
+}
+
+1;
+
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Comment.pm b/lib/CIL/Comment.pm
index 362f094..5fa572b 100644
--- a/lib/CIL/Comment.pm
+++ b/lib/CIL/Comment.pm
@@ -63,6 +63,10 @@ sub prefix {
     return 'c';
 }
 
+sub type {
+    return 'Comment';
+}
+
 sub fields {
     return \@FIELDS;
 }
diff --git a/lib/CIL/Git.pm b/lib/CIL/Git.pm
new file mode 100644
index 0000000..a38323c
--- /dev/null
+++ b/lib/CIL/Git.pm
@@ -0,0 +1,139 @@
+## ----------------------------------------------------------------------------
+# cil is a Command line Issue List
+# Copyright (C) 2008 Andrew Chilton
+#
+# This file is part of 'cil'.
+#
+# cil is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+## ----------------------------------------------------------------------------
+
+package CIL::Git;
+
+use strict;
+use warnings;
+use Carp;
+use List::Util qw(reduce);
+use Git;
+
+use base qw(Class::Accessor);
+
+sub git {
+    my $self = shift;
+    $self->{git} ||= Git->repository;
+}
+
+sub glob_rev {
+    my ($self, $rev, $path) = @_;
+
+    # only support globbing the last element
+    my ($dir, $pattern) = $path =~ m{^([^\*]*/)([^/]*)$}
+        or croak "unsupported pattern '$path'";
+    $pattern =~ s{([\\\.])}{\\$1}g;
+    $pattern =~ s{\*}{.*}g;
+    my @match;
+    $DB::single = 1;
+    for ( $self->git->command("ls-tree", $rev, $dir) ) {
+        chomp;
+        my ($blobid, $path) = m{([0-9a-f]{40})\s+(.*)} or die;
+        if ( $path =~ m{^\Q$dir\E$pattern$} ) {
+            push @match, $path;
+        }
+    }
+    @match;
+}
+
+sub file_exists {
+    my ($self, $rev, $path) = @_;
+
+    my $output = eval { $self->git->command("cat-file", "-t", "$rev:$path") };
+    return ( $output && $output =~ /blob/ );
+}
+
+sub dir_exists {
+    my ($self, $rev, $path) = @_;
+
+    my $output = eval { $self->git->command("cat-file", "-t", "$rev:$path") };
+    return ( $output && $output =~ /tree/ );
+}
+
+sub get_fh {
+    my ($self, $rev, $path) = @_;
+    $self->git->command_output_pipe("cat-file", "blob", "$rev:$path");
+}
+
+sub UserName {
+    return $_[0]->git->config( 'user.name' );
+}
+
+sub UserEmail {
+    return $_[0]->git->config( 'user.email' );
+}
+
+sub branches {
+    my ($self) = @_;
+    return $self->git->command('branch');
+}
+
+sub switch_to_branch {
+    my ($self, $branch_name) = @_;
+    $self->git->command('checkout', $branch_name);
+}
+
+sub create_branch {
+    my ($self, $branch_name) = @_;
+    $self->git->command('checkout', '-b', $branch_name);
+}
+
+sub add {
+    my ($self, $cil, @entities) = @_;
+
+    my @filenames;
+    foreach my $entity ( @entities ) {
+        my $filename = $entity->filename($cil, $entity->name());
+        push @filenames, $filename;
+    }
+    return $self->git->command('add', @filenames);
+}
+
+sub commit {
+    my ($self, $cil, $message, @entities) = @_;
+
+    my @filenames;
+    foreach my $entity ( @entities ) {
+        my $filename = $entity->filename($cil, $entity->name());
+        push @filenames, $filename;
+    }
+
+    $message = 'cil-' . $entities[0]->name . ": $message";
+    return $self->git->command('commit', '-m', $message, @filenames);
+}
+
+sub commit_multiple {
+    my ($self, $cil, $message, @entities) = @_;
+
+    my @filenames;
+    foreach my $entity ( @entities ) {
+        my $filename = $entity->filename($cil, $entity->name());
+        push @filenames, $filename;
+    }
+
+    my $commit_list_string = reduce { $a . $b } map { "* cil-" . $_->name . "\n" } @entities;
+
+    return $self->git->command('commit', '-m', "$message\n\n$commit_list_string", @filenames);
+}
+
+## ----------------------------------------------------------------------------
+1;
+## ----------------------------------------------------------------------------
diff --git a/lib/CIL/Issue.pm b/lib/CIL/Issue.pm
index eff317f..c1360d0 100644
--- a/lib/CIL/Issue.pm
+++ b/lib/CIL/Issue.pm
@@ -82,6 +82,10 @@ sub prefix {
     return 'i';
 }
 
+sub type {
+    return 'Issue';
+}
+
 sub fields {
     return \@FIELDS;
 }
@@ -131,8 +135,22 @@ sub add_label {
     croak 'provide a label when adding one'
         unless defined $label;
 
+    # return if we already have this label
+    return if grep { $_ eq $label } @{$self->{data}{Label}};
+
     push @{$self->{data}{Label}}, $label;
-    $self->flag_as_updated();
+    $self->set_updated_now();
+}
+
+sub remove_label {
+    my ($self, $label) = @_;
+
+    croak 'provide a label when removing one'
+        unless defined $label;
+
+    # remove this label
+    @{$self->{data}{Label}} = grep { $_ ne $label } @{$self->{data}{Label}};
+    $self->set_updated_now();
 }
 
 sub add_comment {
@@ -165,8 +183,11 @@ sub add_depends_on {
     croak 'provide an issue name when adding a depends'
         unless defined $depends;
 
+    # return if we already have this depends
+    return if grep { $_ eq $depends } @{$self->{data}{DependsOn}};
+
     push @{$self->{data}{DependsOn}}, $depends;
-    $self->flag_as_updated();
+    $self->set_updated_now();
 }
 
 sub add_precedes {
@@ -175,8 +196,11 @@ sub add_precedes {
     croak 'provide an issue name when adding a precedes'
         unless defined $precedes;
 
+    # return if we already have this precedes
+    return if grep { $_ eq $precedes } @{$self->{data}{Precedes}};
+
     push @{$self->{data}{Precedes}}, $precedes;
-    $self->flag_as_updated();
+    $self->set_updated_now();
 }
 
 sub LabelList {
diff --git a/lib/CIL/Utils.pm b/lib/CIL/Utils.pm
index 47f7ada..cad802f 100644
--- a/lib/CIL/Utils.pm
+++ b/lib/CIL/Utils.pm
@@ -29,11 +29,13 @@ use File::Temp qw(tempfile);
 use Email::Find;
 use POSIX qw(getpgrp tcgetpgrp);
 use Fcntl qw(:DEFAULT :flock);
+use Digest::MD5 qw(md5_hex);
 
 ## ----------------------------------------------------------------------------
 # setup some globals
 
 my $editor = $ENV{EDITOR} || 'vi';
+my $y = 'y';
 
 ## ----------------------------------------------------------------------------
 
@@ -76,7 +78,7 @@ sub parse_from_lines {
             $data->{$key} = $value;
         }
     }
-    
+
     # now read everything that's left into the $last_field field (if there is one)
     $data->{$last_field} = join("\n", @lines)
         if defined $last_field;
@@ -124,6 +126,9 @@ sub write_cil_file {
     write_file($filename, $lines);
 }
 
+## ----------------------------------------------------------------------------
+# input
+
 # this method based on Term::CallEditor(v0.11)'s solicit method
 # original: Copyright 2004 by Jeremy Mates
 # copied under the terms of the GPL
@@ -149,7 +154,8 @@ sub solicit {
     flock $fh, LOCK_UN;
 
     # run the editor
-    my $status = system($editor, $filename);
+    my @editor_args = split(/\s+/, $editor);
+    my $status = system(@editor_args, $filename);
 
     # check its return value
     if ( $status != 0 ) {
@@ -183,6 +189,379 @@ sub ensure_interactive {
     return;
 }
 
+sub add_issue_loop {
+    my ($class, $cil, undef, $issue) = @_;
+
+    my $edit = $y;
+
+    # keep going until we get a valid issue or we want to quit
+    while ( $edit eq $y ) {
+        # read in the new issue text
+        my $fh = $class->solicit( $issue->as_output );
+        $issue = CIL::Issue->new_from_fh( 'tmp', $fh );
+
+        # check if the issue is valid
+        if ( $issue->is_valid($cil) ) {
+            $edit = 'n';
+        }
+        else {
+            $class->msg($_) foreach @{ $issue->errors };
+            $edit = ans('Would you like to re-edit (y/n): ');
+        }
+    }
+
+    # if the issue is still invalid, they quit without correcting it
+    return unless $issue->is_valid( $cil );
+
+    # we've got the issue, so let's name it
+    my $unique_str = time . $issue->Inserted . $issue->Summary . $issue->Description;
+    $issue->set_name( substr(md5_hex($unique_str), 0, 8) );
+    $issue->save($cil);
+
+    # should probably be run from with $cil
+    $cil->run_hook('issue_post_save', $issue);
+
+    $class->display_issue($cil, $issue);
+
+    return $issue;
+}
+
+sub add_comment_loop {
+    my ($class, $cil, undef, $issue, $comment) = @_;
+
+    my $edit = $y;
+
+    # keep going until we get a valid issue or we want to quit
+    while ( $edit eq $y ) {
+        # read in the new comment text
+        my $fh = CIL::Utils->solicit( $comment->as_output );
+        $comment = CIL::Comment->new_from_fh( 'tmp', $fh );
+
+        # check if the comment is valid
+        if ( $comment->is_valid($cil) ) {
+            $edit = 'n';
+        }
+        else {
+            $class->msg($_) foreach @{ $issue->errors };
+            $edit = $class->ans('Would you like to re-edit (y/n): ');
+        }
+    }
+
+    # if the comment is still invalid, they quit without correcting it
+    return unless $comment->is_valid( $cil );
+
+    # we've got the comment, so let's name it
+    my $unique_str = time . $comment->Inserted . $issue->Description;
+    $comment->set_name( substr(md5_hex($unique_str), 0, 8) );
+
+    # finally, save it
+    $comment->save($cil);
+
+    # add the comment to the issue, update it's timestamp and save it out
+    $issue->add_comment( $comment );
+    $issue->save($cil);
+    $class->display_issue_full($cil, $issue);
+
+    return $comment;
+}
+
+## ----------------------------------------------------------------------------
+# loading
+
+sub load_issue_fuzzy {
+    my ($class, $cil, $partial_name) = @_;
+
+    my $issues = $cil->list_issues_fuzzy( $partial_name );
+    unless ( defined $issues ) {
+        $class->fatal("Couldn't find any issues using '$partial_name'");
+    }
+
+    if ( @$issues > 1 ) {
+        $class->fatal('found multiple issues which match that name: ' . join(' ', map { $_->{name} } @$issues));
+    }
+
+    my $issue_name = $issues->[0]->{name};
+    my $issue = CIL::Issue->new_from_name($cil, $issue_name);
+    unless ( defined $issue ) {
+        $class->fatal("Couldn't load issue '$issue_name'");
+    }
+
+    return $issue;
+}
+
+sub load_comment_fuzzy {
+    my ($class, $cil, $partial_name) = @_;
+
+    my $comments = $cil->list_comments_fuzzy( $partial_name );
+    unless ( defined $comments ) {
+        $class->fatal("Couldn't find any comments using '$partial_name'");
+    }
+
+    if ( @$comments > 1 ) {
+        $class->fatal('found multiple comments which match that name: ' . join(' ', map { $_->{name} } @$comments));
+    }
+
+    my $comment_name = $comments->[0]->{name};
+    my $comment = CIL::comment->new_from_name($cil, $comment_name);
+    unless ( defined $comment ) {
+        $class->fatal("Couldn't load comment '$comment_name'");
+    }
+
+    return $comment;
+}
+
+sub load_attachment_fuzzy {
+    my ($class, $cil, $partial_name) = @_;
+
+    my $attachments = $cil->list_attachments_fuzzy( $partial_name );
+    unless ( defined $attachments ) {
+        $class->fatal("Couldn't find any attachments using '$partial_name'");
+    }
+
+    if ( @$attachments > 1 ) {
+        $class->fatal('found multiple attachments which match that name: ' . join(' ', map { $_->{name} } @$attachments));
+    }
+
+    my $attachment_name = $attachments->[0]->{name};
+    my $attachment = CIL::Attachment->new_from_name($cil, $attachment_name);
+    unless ( defined $attachment ) {
+        $class->fatal("Couldn't load attachment '$partial_name'");
+    }
+
+    return $attachment;
+}
+
+## ----------------------------------------------------------------------------
+# display
+
+sub display_issue {
+    my ($class, $cil, $issue) = @_;
+
+    $class->separator();
+    $class->title( 'Issue ' . $issue->name() );
+    $class->field( 'Summary', $issue->Summary() );
+    $class->field( 'Status', $issue->Status() );
+    $class->field( 'CreatedBy', $issue->CreatedBy() );
+    $class->field( 'AssignedTo', $issue->AssignedTo() );
+    $class->field( 'Label', $_ )
+        foreach sort @{$issue->LabelList()};
+    $class->field( 'Comment', $_ )
+        foreach sort @{$issue->CommentList()};
+    $class->field( 'Attachment', $_ )
+        foreach sort @{$issue->AttachmentList()};
+    $class->field( 'DependsOn', $_ )
+        foreach sort @{$issue->DependsOnList()};
+    $class->field( 'Precedes', $_ )
+        foreach sort @{$issue->PrecedesList()};
+    $class->field( 'Inserted', $issue->Inserted() );
+    $class->field( 'Updated', $issue->Inserted() );
+    $class->text('Description', $issue->Description());
+    $class->separator();
+}
+
+sub display_issue_full {
+    my ($class, $cil, $issue) = @_;
+
+    $class->separator();
+    $class->title( 'Issue ' . $issue->name() );
+    $class->field( 'Summary', $issue->Summary() );
+    $class->field( 'Status', $issue->Status() );
+    $class->field( 'CreatedBy', $issue->CreatedBy() );
+    $class->field( 'AssignedTo', $issue->AssignedTo() );
+    $class->field( 'Label', $_ )
+        foreach sort @{$issue->Label()};
+    $class->field( 'DependsOn', $_ )
+        foreach sort @{$issue->DependsOnList()};
+    $class->field( 'Precedes', $_ )
+        foreach sort @{$issue->PrecedesList()};
+    $class->field( 'Inserted', $issue->Inserted() );
+    $class->field( 'Updated', $issue->Updated() );
+    $class->text('Description', $issue->Description());
+
+    my $comments = $cil->get_comments_for( $issue );
+    foreach my $comment ( @$comments ) {
+        $class->display_comment( $cil, $comment );
+    }
+
+    my $attachments = $cil->get_attachments_for( $issue );
+    foreach my $attachment ( @$attachments ) {
+        $class->display_attachment( $cil, $attachment );
+        $class->msg();
+    }
+
+    $class->separator();
+}
+
+sub display_comment {
+    my ($class, $cil, $comment) = @_;
+
+    $class->title( 'Comment ' . $comment->name() );
+    $class->field( 'CreatedBy', $comment->CreatedBy() );
+    $class->field( 'Inserted', $comment->Inserted() );
+    $class->field( 'Updated', $comment->Inserted() );
+    $class->text('Description', $comment->Description());
+}
+
+sub display_attachment {
+    my ($class, $cil, $attachment) = @_;
+
+    $class->title( 'Attachment ' . $attachment->name() );
+    $class->field( 'Filename', $attachment->Filename() );
+    $class->field( 'CreatedBy', $attachment->CreatedBy() );
+    $class->field( 'Inserted', $attachment->Inserted() );
+    $class->field( 'Updated', $attachment->Inserted() );
+}
+
+sub filter_issues {
+    my ($class, $cil, $issues, $args) = @_;
+
+    # don't filter if we haven't been given anything
+    return $issues unless defined $args;
+    return $issues unless %$args;
+
+    # check that they aren't filtering on both --assigned-to and --is-mine
+    if ( defined $args->{a} and defined $args->{'is-mine'} ) {
+        $class->fatal("the --assigned-to and --is-mine filters are mutually exclusive");
+    }
+
+    # take a copy of the whole lot first (so we don't destroy the input list)
+    my @new_issues = @$issues;
+
+    # firstly, get out the Statuses we want
+    if ( defined $args->{s} ) {
+        @new_issues = grep { $_->Status eq $args->{s} } @new_issues;
+    }
+
+    # then see if we want a particular label (could be a bit nicer)
+    if ( defined $args->{l} ) {
+        my @tmp;
+        foreach my $issue ( @new_issues ) {
+            push @tmp, $issue
+                if grep { $_ eq $args->{l} } @{$issue->LabelList};
+        }
+        @new_issues = @tmp;
+    }
+
+    # filter out dependent on open/closed
+    if ( defined $args->{'is-open'} ) {
+        # just get the open issues
+        @new_issues = grep { $_->is_open($cil) } @new_issues;
+    }
+    if ( defined $args->{'is-closed'} ) {
+        # just get the closed issues
+        @new_issues = grep { $_->is_closed($cil) } @new_issues;
+    }
+
+    # filter out 'created by'
+    if ( defined $args->{c} ) {
+        @new_issues = grep { $args->{c} eq $_->created_by_email } @new_issues;
+    }
+
+    # filter out 'assigned to'
+    $args->{a} = $cil->UserEmail
+        if defined $args->{'is-mine'};
+    if ( defined $args->{a} ) {
+        @new_issues = grep { $args->{a} eq $_->assigned_to_email } @new_issues;
+    }
+
+    return \@new_issues;
+}
+
+sub separator {
+    my ($class) = @_;
+    $class->msg('=' x 79);
+}
+
+sub msg {
+    my ($class, $msg) = @_;
+    print ( defined $msg ? $msg : '' );
+    print "\n";
+}
+
+sub display_issue_summary {
+    my ($class, $issue) = @_;
+
+    my $msg = $issue->name();
+    $msg .= "   ";
+    $msg .= $issue->Status();
+    $msg .= (' ' x ( 13 - length $issue->Status() ));
+    $msg .= $issue->Summary();
+
+    $class->msg($msg);
+}
+
+sub display_issue_headers {
+    my ($class, $issue) = @_;
+
+    $class->title( 'Issue ' . $issue->name() );
+    $class->field( 'Summary', $issue->Summary() );
+    $class->field( 'CreatedBy', $issue->CreatedBy() );
+    $class->field( 'AssignedTo', $issue->AssignedTo() );
+    $class->field( 'Inserted', $issue->Inserted() );
+    $class->field( 'Status', $issue->Status() );
+    $class->field( 'Labels', join(' ', @{$issue->LabelList()}) );
+    $class->field( 'DependsOn', join(' ', @{$issue->DependsOnList()}) );
+    $class->field( 'Precedes', join(' ', @{$issue->PrecedesList()}) );
+}
+
+sub title {
+    my ($class, $title) = @_;
+    my $msg = "--- $title ";
+    $msg .= '-' x (74 - length($title));
+    $class->msg($msg);
+}
+
+sub field {
+    my ($class, $field, $value) = @_;
+    my $msg = "$field";
+    $msg .= " " x (12 - length($field));
+    $class->msg("$msg: " . (defined $value ? $value : '') );
+}
+
+sub text {
+    my ($class, $field, $value) = @_;
+    $class->msg();
+    $class->msg($value);
+    $class->msg();
+}
+
+## ----------------------------------------------------------------------------
+# system
+
+sub check_paths {
+    my ($class, $cil) = @_;
+
+    # make sure an issue directory is available
+    unless ( $cil->dir_exists($cil->IssueDir) ) {
+        $class->fatal("couldn't find '" . $cil->IssueDir . "' directory");
+    }
+}
+
+sub ans {
+    my ($msg) = @_;
+    print $msg;
+    my $ans = <STDIN>;
+    chomp $ans;
+    print "\n";
+    return $ans;
+}
+
+sub err {
+    my ($class, $msg) = @_;
+    print STDERR ( defined $msg ? $msg : '' );
+    print STDERR "\n";
+}
+
+sub fatal {
+    my ($class, $msg) = @_;
+    chomp $msg;
+    print STDERR $msg, "\n";
+    exit 2;
+}
+
+## ----------------------------------------------------------------------------
+# helpers
+
 sub extract_email_address {
     my ($class, $text) = @_;
 
@@ -198,6 +577,11 @@ sub extract_email_address {
     return $email_address;
 }
 
+sub user {
+    my ($class, $cil) = @_;
+    return $cil->UserName . ' <' . $cil->UserEmail . '>';
+}
+
 ## ----------------------------------------------------------------------------
 1;
 ## ----------------------------------------------------------------------------